Class: Source

Inherits:

ApplicationRecord

Object
ActiveRecord::Base
ApplicationRecord
Source

show all

Includes:: Housekeeping::Timestamps, Housekeeping::Users, Shared::AlternateValues, Shared::DataAttributes, Shared::Documentation, Shared::HasPapertrail, Shared::Identifiers, Shared::IsData, Shared::Notes, Shared::SharedAcrossProjects, Shared::Tags, SoftValidation

Defined in:: app/models/source.rb

Overview

A Source is the metadata that identifies the origin of some information/data.

The primary purpose of Source metadata is to allow the user to find the source, that’s all.

See en.wikipedia.org/wiki/BibTeX for a definition of attributes, in nearly all cases they are 1:1 with the TW model. We use this github.com/inukshuk/bibtex-ruby awesomeness. See github.com/inukshuk/bibtex-ruby/tree/master/lib/bibtex/entry, in particular rdf_converter.rb for the types of field managed.

Direct Known Subclasses

Bibtex, Human, Verbatim

Defined Under Namespace

Classes: Bibtex, Human, Verbatim

Constant Summary collapse

ALTERNATE_VALUES_FOR =

[
:address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
:publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

Constants included from SoftValidation

SoftValidation::ANCESTORS_WITH_SOFT_VALIDATIONS

Instance Attribute Summary collapse

#abstract ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#address ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#annote ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#author ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#bibtex_type ⇒ String

Alias for “type” in the bibtex framework see en.wikipedia.org/wiki/BibTeX#Field_types.
#booktitle ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#cached ⇒ String

Calculated full citation, searched again in “full text”.
#cached_author_string ⇒ String

Calculated author string.
#cached_nomenclature_date ⇒ DateTime

Date sensu nomenclature algorithm in TaxonWorks (see Utilities::Dates).
#chapter ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#copyright ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#crossref ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#day ⇒ Integer

The calendar day (1-31).
#doi ⇒ String

When provided also cloned to an Identifier::Global.
#edition ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#editor ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#howpublished ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#institution ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#isbn ⇒ String
#issn ⇒ String
#journal ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#key ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#language ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#language_id ⇒ Integer

The TaxonWorks normalization of language to Language.
#month ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types stored as a three letter value, see ::VALID_BIBTEX_MONTHS.
#no_year_suffix_validation ⇒ Boolean^?

When true, cached values are not built.
#note ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#number ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#organization ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#pages ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#publisher ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#school ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#serial_id ⇒ Integer

The TaxonWorks Serial.
#series ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#stated_year ⇒ String

See source/bibtex.rb TODO: Why is this character but year is int?.
#title ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#translator ⇒ String
#type ⇒ String

An exception to the 1:1 modelling.
#url ⇒ String
#verbatim ⇒ String

The full citation, used only for type = SourceVerbatim.
#verbatim_contents ⇒ String
#verbatim_keywords ⇒ String
#volume ⇒ String

See en.wikipedia.org/wiki/BibTeX#Field_types.
#year ⇒ Integer

See en.wikipedia.org/wiki/BibTeX#Field_types.
#year_suffix ⇒ String

Arbitrary user-provided suffix to the year.

Attributes included from Housekeeping::Users

#by

Class Method Summary collapse

.batch_create(file) ⇒ Array, Boolean
.batch_preview(file) ⇒ [Array, message]

TODO: return a more informative response?.
.select_optimized(user_id, project_id, target = 'TaxonName') ⇒ Hash

Sources optimized for user selection.
.used_recently(user_id, project_id, used_on = 'TaxonName') ⇒ Scope

The max 10 most recently used (1 week, could parameterize) TaxonName, as used.

Instance Method Summary collapse

#author_year ⇒ String

A string that represents the authors last_names and year (no suffix).
#cited_objects ⇒ Array

Objects this source is linked to through citations.
#clone ⇒ Source
#get_cached ⇒ Object protected

Defined in subclasses.
#is_bibtex? ⇒ Boolean
#is_in_project?(project_id) ⇒ Boolean
#nomenclature_date ⇒ Date

Month handling allows values from bibtex like ‘may’ to be handled.
#reject_project_sources(attributed) ⇒ Boolean protected
#set_cached ⇒ Nil protected

Defined in subclasses.
#sv_cached_names ⇒ Object protected
#sv_fix_cached_names ⇒ Object protected
#sv_fix_stated_year ⇒ Object protected
#sv_html_tags ⇒ Object protected
#sv_stated_year ⇒ Object protected

Instance Attribute Details

#abstract ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#address ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#annote ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#author ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#bibtex_type ⇒ `String`

Returns alias for “type” in the bibtex framework see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

alias for “type” in the bibtex framework see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#booktitle ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#cached ⇒ `String`

Returns calculated full citation, searched again in “full text”.

Returns:

(String) —

calculated full citation, searched again in “full text”

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#cached_author_string ⇒ `String`

Returns calculated author string.

Returns:

(String) —

calculated author string

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#cached_nomenclature_date ⇒ `DateTime`

Returns Date sensu nomenclature algorithm in TaxonWorks (see Utilities::Dates).

Returns:

(DateTime) —

Date sensu nomenclature algorithm in TaxonWorks (see Utilities::Dates)

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#chapter ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#copyright ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#crossref ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#day ⇒ `Integer`

Returns the calendar day (1-31).

Returns:

(Integer) —

the calendar day (1-31)

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#doi ⇒ `String`

Returns When provided also cloned to an Identifier::Global. See en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

When provided also cloned to an Identifier::Global. See en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#edition ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#editor ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#howpublished ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#institution ⇒ `String`

Returns see en.wikipedia.org/wiki/BibTeX#Field_types.

Returns:

(String) —

see en.wikipedia.org/wiki/BibTeX#Field_types

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]
  def nomenclature_date
    Utilities::Dates.nomenclature_date(day, Utilities::Dates.month_index(month), year)&.to_date
  end

  # @return [Source]
  def clone
    s = dup

    m = "[CLONE of #{id}] "

    case type
    when 'Source::Verbatim'
      s.verbatim = m + verbatim.to_s
    when 'Source::Bibtex'
      s.title = m + title.to_s
    end

    roles.reload.each do |r|
      s.roles << Role.new(person: r.person, type: r.type, position: r.position )
    end

    s.year_suffix = nil
    s.save
    s
  end

  protected

  # Defined in subclasses
  # @return [Nil]
  def set_cached
  end

  # Defined in subclasses
  def get_cached
  end

    # @param [Hash] attributed
  # @return [Boolean]
  def reject_project_sources(attributed)
    return true if attributed['project_id'].blank?
    return true if ProjectSource.where(project_id: attributed['project_id'], source_id: id).any?
  end

  def sv_cached_names
    true # see validation in subclasses
  end

  def sv_fix_cached_names
    begin
      Source.transaction do
        self.set_cached
      end
      true
    rescue
      false
    end
  end

  def sv_stated_year
    soft_validations.add(
      :base, "'Stated year' is not needed if identical to 'year'; applying the Fix will delete it",
      success_message: "'Stated year' was deleted",
      failure_message:  "Failed to delete 'Stated year'") if year.to_s == stated_year.to_s
  end

  def sv_fix_stated_year
    begin
      Source.transaction do
        self.stated_year = nil
        self.save
      end
      true
    rescue
      false
    end
  end


  def sv_html_tags
    if title.present?
      str = title.squish.gsub(/\<i>[^<>]*?<\/i>/, '')
      soft_validations.add(:title, 'The title contains unmatched html tags') if str.include?('<i>') || str.include?('</i>')
    end
end
end

#isbn ⇒ `String`

TODO:

Returns:

(String)

# File 'app/models/source.rb', line 188

class Source < ApplicationRecord
  include Housekeeping::Users
  include Housekeeping::Timestamps
  include Shared::AlternateValues
  include Shared::DataAttributes
  include Shared::Documentation
  include Shared::Identifiers
  include Shared::Notes
  include Shared::SharedAcrossProjects
  include Shared::Tags
  include Shared::HasPapertrail
  include SoftValidation
  include Shared::IsData

  ignore_whitespace_on(:verbatim_contents)

  ALTERNATE_VALUES_FOR = [
    :address, :annote, :booktitle, :edition, :editor, :institution, :journal, :note, :organization,
    :publisher, :school, :title, :doi, :abstract, :language, :translator, :author, :url].freeze

  # @return [Boolean, nil]
  #   When true, cached values are not built
  attr_accessor :no_year_suffix_validation

  # Keep this order for citations/topics
  has_many :citations, inverse_of: :source, dependent: :restrict_with_error
  has_many :origin_citations, -> {where(citations: {is_original: true})}, class_name: 'Citation', dependent: :restrict_with_error, inverse_of: :source
  has_many :citation_topics, through: :citations, inverse_of: :source
  has_many :topics, through: :citation_topics, inverse_of: :sources

  # !! must be below has_many :citations
  # has_many :asserted_distributions, through: :citations, source: :citation_object, source_type: 'AssertedDistribution'

  has_many :project_sources, dependent: :destroy
  has_many :projects, through: :project_sources

  after_save :set_cached

  validates_presence_of :type
  validates :type, inclusion: {in: ['Source::Bibtex', 'Source::Human', 'Source::Verbatim']} # TODO: not needed

  accepts_nested_attributes_for :project_sources, reject_if: :reject_project_sources

  soft_validate(
    :sv_cached_names,
    set: :cached_names,
    fix: :sv_fix_cached_names,
    name: 'Cached names',
    description: 'Check if cached values need to be updated' )

  soft_validate(
    :sv_stated_year,
    set: :stated_year,
    fix: :sv_fix_stated_year,
    name: 'Stated year',
    description: "'Stated year' is not needed if identical to 'year'" )

  soft_validate(
    :sv_html_tags,
    set: :html_tags,
    name: 'html tags',
    description: 'Check if html has both open and close tags' )

    # Redirect type here
  # @param [String] file
  # @return [[Array, message]]
  #   TODO: return a more informative response?
  def self.batch_preview(file)
    begin
      bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
      sources = []
      bibliography.each do |record|
        a = Source::Bibtex.new_from_bibtex(record)
        sources.push(a)
      end
      return sources, nil
    rescue BibTeX::ParseError => e
      return [], e.message
    rescue
      raise
    end
  end

  # @return [String]
  #   A string that represents the authors last_names and year (no suffix)
  def author_year
    return 'not yet calculated' if new_record?
    [cached_author_string, year].compact.join(', ')
  end

    # @param [String] file
  # @return [Array, Boolean]
  def self.batch_create(file)
    sources = []
    valid = 0
    begin
      # error_msg = []
      Source.transaction do
        bibliography = BibTeX::Bibliography.parse(file.read.force_encoding('UTF-8'), filter: :latex)
        bibliography.each do |record|
          a = Source::Bibtex.new_from_bibtex(record)
          if a.valid?
            if a.save
              valid += 1
            end
          else
            # error_msg = a.errors.messages.to_s
          end
          sources.push(a)
        end
      end
    rescue
      return false
    end
    return {records: sources, count: valid}
  end

  # @param used_on [String] a model name
  # @return [Scope]
  #    the max 10 most recently used (1 week, could parameterize) TaxonName, as used
  def self.used_recently(user_id, project_id, used_on = 'TaxonName')
    Source.select('sources.id').
      joins(:citations)
          .where(citations: {updated_by_id: user_id,
                 project_id:,
                 citation_object_type: used_on,
                 updated_at: 1.week.ago..})
         .order('citations.updated_at DESC')
       .pluck(:id).uniq
  end

  # @params target [String] a citable model name
  # @return [Hash] sources optimized for user selection
  def self.select_optimized(user_id, project_id, target = 'TaxonName')
    r = used_recently(user_id, project_id, target)
    h = {
      quick: [],
      pinboard: Source.pinned_by(user_id).where(pinboard_items: {project_id:}).to_a,
      recent: []
    }

    if r.empty?
      h[:recent] = Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a
      h[:quick] = Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a
    else
      h[:recent] =
        (Source.where(created_by_id: user_id, updated_at: 2.hours.ago..Time.now )
        .order('created_at DESC')
        .limit(5).order(:cached).to_a +
      Source.where('"sources"."id" IN (?)', r.first(6) ).to_a).uniq
      h[:quick] = ( Source.pinned_by(user_id).pinboard_inserted.where(pinboard_items: {project_id:}).to_a +
                   Source.where('"sources"."id" IN (?)', r.first(4) ).to_a).uniq
    end

    h
  end

  # @return [Array]
  #    objects this source is linked to through citations
  def cited_objects
    self.citations.collect { |t| t.citation_object }
  end

  # @return [Boolean]
  def is_bibtex?
    type == 'Source::Bibtex'
  end

  # @return [Boolean]
  def is_in_project?(project_id)
    projects.where(id: project_id).any?
  end

  # Month handling allows values from bibtex like 'may' to be handled
  # @return [Date]

Class: Source

Overview

Direct Known Subclasses

Defined Under Namespace

Constant Summary collapse

Constants included from SoftValidation

Instance Attribute Summary collapse

Attributes included from Housekeeping::Users

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Shared::IsData

Methods included from SoftValidation

Methods included from Shared::HasPapertrail

Methods included from Shared::Tags

Methods included from Shared::Notes

Methods included from Shared::Identifiers

Methods included from Shared::Documentation

Methods included from Shared::DataAttributes

Methods included from Shared::AlternateValues

Methods included from Housekeeping::Timestamps

Methods included from Housekeeping::Users

Methods inherited from ApplicationRecord

Instance Attribute Details

#abstract ⇒ String

#address ⇒ String

#annote ⇒ String

#author ⇒ String

#bibtex_type ⇒ String

#booktitle ⇒ String

#cached ⇒ String

#cached_author_string ⇒ String

#cached_nomenclature_date ⇒ DateTime

#chapter ⇒ String

#copyright ⇒ String

#crossref ⇒ String

#day ⇒ Integer

#doi ⇒ String

#edition ⇒ String

#editor ⇒ String

#howpublished ⇒ String

#institution ⇒ String

#isbn ⇒ String

#abstract ⇒ `String`

#address ⇒ `String`

#annote ⇒ `String`

#author ⇒ `String`

#bibtex_type ⇒ `String`

#booktitle ⇒ `String`

#cached ⇒ `String`

#cached_author_string ⇒ `String`

#cached_nomenclature_date ⇒ `DateTime`

#chapter ⇒ `String`

#copyright ⇒ `String`

#crossref ⇒ `String`

#day ⇒ `Integer`

#doi ⇒ `String`

#edition ⇒ `String`

#editor ⇒ `String`

#howpublished ⇒ `String`

#institution ⇒ `String`

#isbn ⇒ `String`