alexandria-book-collection-manager 0.7.5 → 0.7.9

data/lib/alexandria/book_providers/barnes_and_noble.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-# -*- ruby -*-
-#
-# Copyright (C) 2009 Cathal Mc Ginley
-# Copyright (C) 2011, 2014, 2015 Matijs van Zuijlen
-#
-# Alexandria is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-#
-# Alexandria is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with Alexandria; see the file COPYING.  If not,
-# write to the Free Software Foundation, Inc., 51 Franklin Street,
-# Fifth Floor, Boston, MA 02110-1301 USA.
-
-# http://en.wikipedia.org/wiki/Barnes_&_Noble
-
-# New BarnesAndNoble provider, taken from the Palatina MetaDataSource
-# and modified to fit the structure of Alexandria book providers.
-# Completely rewritten by Cathal Mc Ginley (18 Dec 2009)
-
-# NOTE: this modified version is based on the Alexandria WorldCat provider.
-
-require "cgi"
-require "alexandria/net"
-require "alexandria/book_providers/web"
-
-module Alexandria
-  class BookProviders
-    class BarnesAndNobleProvider < WebsiteBasedProvider
-      include Alexandria::Logging
-
-      SITE = "http://www.barnesandnoble.com"
-
-      BASE_ISBN_SEARCH_URL = "http://www.barnesandnoble.com/s/%s"
-
-      BASE_SEARCH_URL = "http://search.barnesandnoble.com/booksearch" \
-        "/results.asp?%s=%s" # type, term
-
-      def initialize
-        super("BarnesAndNoble", "BarnesAndNoble")
-        @agent = nil
-        prefs.read
-      end
-
-      def agent
-        @agent ||= Alexandria::WWWAgent.new
-        @agent
-      end
-
-      def fetch_redirectly(uri_str, limit = 5)
-        raise NoResultsError, "HTTP redirect too deep" if limit.zero?
-
-        if limit < 10
-          sleep 0.1
-          log.debug { "Redirectly :: #{uri_str}" }
-        else
-          log.debug { "Fetching   :: #{uri_str}" }
-        end
-        response = agent.get(uri_str)
-        log.debug { response.inspect }
-        case response
-        when Net::HTTPSuccess     then response
-        when Net::HTTPRedirection then
-          redirect = URI.parse response["Location"]
-          redirect = URI.parse(uri_str) + redirect if redirect.relative?
-          fetch_redirectly(redirect.to_s, (limit - 1))
-        else
-          response.error!
-        end
-      end
-
-      def search(criterion, type)
-        req = create_search_uri(type, criterion)
-        puts "Requesting #{req}" if $DEBUG
-        html_data = fetch_redirectly(req)
-
-        if type == SEARCH_BY_ISBN
-          parse_result_data(html_data.body, criterion)
-        else
-          results = parse_search_result_data(html_data.body)
-          raise NoResultsError if results.empty?
-
-          results.map { |result| get_book_from_search_result(result) }
-        end
-      end
-
-      def url(book)
-        create_search_uri(SEARCH_BY_ISBN, book.isbn)
-      rescue StandardError => ex
-        log.warn { "Cannot create url for book #{book}; #{ex.message}" }
-        nil
-      end
-
-      def create_search_uri(search_type, search_term)
-        (search_type_code = {
-          SEARCH_BY_AUTHORS => "ATH",
-          SEARCH_BY_TITLE   => "TTL",
-          SEARCH_BY_KEYWORD => "WRD" # SEARCH_BY_PUBLISHER => 'PBL' # not implemented
-        }[search_type]) || ""
-        if search_type == SEARCH_BY_ISBN
-          BASE_ISBN_SEARCH_URL % Library.canonicalise_ean(search_term) # isbn-13
-        else
-          search_term_encoded = CGI.escape(search_term)
-          format(BASE_SEARCH_URL, search_type_code, search_term_encoded)
-        end
-      end
-
-      def get_book_from_search_result(result)
-        log.debug { "Fetching book from #{result[:url]}" }
-        html_data = transport.get_response(URI.parse(result[:url]))
-        parse_result_data(html_data.body)
-      end
-
-      def parse_search_result_data(html)
-        doc = html_to_doc(html)
-        book_search_results = []
-        begin
-          result_divs = doc / 'div[@class*="book-container"]'
-          result_divs.each do |div|
-            result = {}
-            # img = div % 'div.book-image/a/img'
-            # result[:image_url] = img['src'] if img
-            title_header = div % "h2"
-            title_links = title_header / "a"
-            result[:title] = title_links.first.inner_text
-            result[:url] = title_links.first["href"]
-
-            book_search_results << result
-          end
-        rescue StandardError => ex
-          trace = ex.backtrace.join("\n> ")
-          log.warn do
-            "Failed parsing search results for Barnes & Noble " \
-            "#{ex.message} #{trace}"
-          end
-        end
-        book_search_results
-      end
-
-      def parse_result_data(html, _search_isbn = nil, _recursing = false)
-        doc = html_to_doc(html)
-        begin
-          book_data = {}
-
-          dl = (doc / "dl").first
-          dts = dl.children_of_type("dt")
-          dts.each do |dt|
-            value = dt.next_sibling.inner_text
-            case dt.inner_text
-            when /ISBN-13/
-              book_data[:isbn] = Library.canonicalise_ean(value)
-            when /Publisher/
-              book_data[:publisher] = value
-            when /Publication data/
-              value =~ /\d{2}.\d{2}.(\d{4})/
-              year = Regexp.last_match[1]
-              book_data[:publisher] = year
-            end
-          end
-
-          meta = doc / "meta"
-          meta.each do |it|
-            attrs = it.attributes
-            property = attrs["property"]
-            next unless property
-
-            case property
-            when "og:title"
-              book_data[:title] = attrs["content"]
-            when "og:image"
-              book_data[:image_url] = attrs["content"]
-            end
-          end
-
-          author_links = doc / "span.contributors a"
-          authors = author_links.map(&:inner_text)
-          book_data[:authors] = authors
-
-          book_data[:binding] = ""
-          selected_format = (doc / "#availableFormats li.selected a.tabTitle").first
-          book_data[:binding] = selected_format.inner_text if selected_format
-
-          book = Book.new(book_data[:title], book_data[:authors],
-                          book_data[:isbn], book_data[:publisher],
-                          book_data[:publication_year],
-                          book_data[:binding])
-          [book, book_data[:image_url]]
-        rescue StandardError => ex
-          raise ex if ex.instance_of? NoResultsError
-
-          trace = ex.backtrace.join("\n> ")
-          log.warn do
-            "Failed parsing search results for BarnesAndNoble " \
-            "#{ex.message} #{trace}"
-          end
-          raise NoResultsError
-        end
-      end
-    end # class BarnesAndNobleProvider
-  end # class BookProviders
-end # module Alexandria

data/lib/alexandria/book_providers/proxis.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-# This file is part of Alexandria.
-#
-# See the file README.md for authorship and licensing information.
-
-# New Proxis provider, taken from Palatina MetaDataSource and modified
-# for Alexandria. (20 Dec 2009)
-
-require "cgi"
-require "alexandria/book_providers/web"
-
-module Alexandria
-  class BookProviders
-    class ProxisProvider < WebsiteBasedProvider
-      # include GetText
-      include Alexandria::Logging
-      # GetText.bindtextdomain(Alexandria::TEXTDOMAIN, :charset => "UTF-8")
-
-      # Proxis essentially has three book databases, NL, FR and EN.
-      # Currently, this provider only searches the NL database, since
-      # it adds most to Alexandria (Amazon already has French and
-      # English titles).
-
-      SITE = "http://www.proxis.nl"
-      BASE_SEARCH_URL = "#{SITE}/NLNL/Search/IndexGSA.aspx?search=%s" \
-        "&shop=100001NL&SelRubricLevel1Id=100001NL"
-      ISBN_REDIRECT_BASE_URL = "#{SITE}/NLNL/Search/Index.aspx?search=%s" \
-        "&shop=100001NL&SelRubricLevel1Id=100001NL"
-
-      def initialize
-        super("Proxis", "Proxis (Belgium)")
-        # prefs.add("lang", _("Language"), "fr",
-        #          LANGUAGES.keys)
-        prefs.read
-      end
-
-      def search(criterion, type)
-        req = create_search_uri(type, criterion)
-        puts req if $DEBUG
-        html_data = transport.get_response(URI.parse(req))
-
-        results = parse_search_result_data(html_data.body)
-        raise NoResultsError if results.empty?
-
-        if type == SEARCH_BY_ISBN
-          get_book_from_search_result(results.first)
-        else
-          results.map { |result| get_book_from_search_result(result) }
-        end
-      end
-
-      def create_search_uri(search_type, search_term)
-        if search_type == SEARCH_BY_ISBN
-          BASE_SEARCH_URL % Library.canonicalise_ean(search_term)
-        else
-          BASE_SEARCH_URL % CGI.escape(search_term)
-        end
-      end
-
-      def get_book_from_search_result(result)
-        log.debug { "Fetching book from #{result[:lookup_url]}" }
-        html_data = transport.get_response(URI.parse(result[:lookup_url]))
-        parse_result_data(html_data.body)
-      end
-
-      def url(book)
-        if book.isbn.nil? || book.isbn.empty?
-          ISBN_REDIRECT_BASE_URL % Library.canonicalise_ean(book.isbn)
-        end
-      end
-
-      ## from Palatina
-      def text_of(node)
-        if node.nil?
-          nil
-        elsif node.text?
-          node.to_html
-        elsif node.elem?
-          if node.children.nil?
-            nil
-          else
-            node_text = node.children.map { |n| text_of(n) }.join
-            node_text.strip.squeeze(" ")
-          end
-        end
-      end
-
-      def parse_search_result_data(html)
-        doc = html_to_doc(html)
-        book_search_results = []
-        items = doc.search("table.searchResult tr")
-        items.each do |item|
-          result = {}
-          title_link = item % "h5 a"
-          if title_link
-            result[:title] = text_of(title_link)
-            result[:lookup_url] = title_link["href"]
-            unless /^http/.match?(result[:lookup_url])
-              result[:lookup_url] = "#{SITE}#{result[:lookup_url]}"
-            end
-          end
-          book_search_results << result
-        end
-        # require 'pp'
-        # pp book_search_results
-        # raise :Ruckus
-        book_search_results
-      end
-
-      def data_for_header(th)
-        tr = th.parent
-        td = tr.at("td")
-        text_of(td) if td
-      end
-
-      def parse_result_data(html)
-        doc = html_to_doc(html)
-        book_data = {}
-        book_data[:authors] = []
-        # TITLE
-        if (title_header = doc.search("div.detailBlock h3"))
-          header_spans = title_header.first.search("span")
-          title = text_of(header_spans.first)
-          title = Regexp.last_match[1].strip if title =~ /(.+)-$/
-          book_data[:title] = title
-        end
-
-        info_headers = doc.search("table.productInfoTable th")
-
-        isbns = []
-        unless info_headers.empty?
-          info_headers.each do |th|
-            isbns << data_for_header(th) if /(ISBN|EAN)/.match?(th.inner_text)
-          end
-          book_data[:isbn] = Library.canonicalise_ean(isbns.first)
-        end
-
-        # book = Book.new(title, ISBN.get(isbns.first))
-
-        unless info_headers.empty?
-          info_headers.each do |th|
-            header_text = th.inner_text
-            if /Type/.match?(header_text)
-              book_data[:binding] = data_for_header(th)
-            elsif /Verschijningsdatum/.match?(header_text)
-              date = data_for_header(th)
-              date =~ %r{/([\d]{4})}
-              book_data[:publish_year] = Regexp.last_match[1].to_i
-            elsif /Auteur/.match?(header_text)
-              book_data[:authors] << data_for_header(th)
-            elsif /Uitgever/.match?(header_text)
-              book_data[:publisher] = data_for_header(th)
-            end
-          end
-        end
-
-        image_url = nil
-        if (cover_img = doc.at("img[@id$='imgProduct']"))
-          image_url = if /^http/.match?(cover_img["src"])
-                        cover_img["src"]
-                      else
-                        "#{SITE}/#{cover_img['src']}" # TODO: use html <base>
-                      end
-          image_url = nil if /ProductNoCover/.match?(image_url)
-        end
-
-        book = Book.new(book_data[:title], book_data[:authors],
-                        book_data[:isbn], book_data[:publisher],
-                        book_data[:publish_year], book_data[:binding])
-        [book, image_url]
-      end
-    end
-  end
-end

data/lib/alexandria/book_providers/siciliano.rb

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (C) 2004 Laurent Sansonetti
-# Copyright (C) 2007 Laurent Sansonetti and Marco Costantini
-# Copyright (C) 2009 Cathal Mc Ginley
-# Copyright (C) 2011, 2014, 2016 Matijs van Zuijlen
-#
-# Alexandria is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-#
-# Alexandria is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with Alexandria; see the file COPYING.  If not,
-# write to the Free Software Foundation, Inc., 51 Franklin Street,
-# Fifth Floor, Boston, MA 02110-1301 USA.
-
-# Adapted code from 'bn.rb' (I hope that it works!)
-
-# Almost completely rewritten by Cathal Mc Ginley (21 Feb 2009)
-# based on the new code for Palatina
-
-require "net/http"
-require "cgi"
-require "alexandria/book_providers/web"
-
-module Alexandria
-  class BookProviders
-    class SicilianoProvider < WebsiteBasedProvider
-      include Logging
-
-      SITE = "http://www.siciliano.com.br"
-
-      # The string interpolations in this URL are the search term and search
-      # type, respectively.
-      BASE_SEARCH_URL = "#{SITE}/pesquisaweb/pesquisaweb.dll/pesquisa?" \
-        "&FIL_ID=102" \
-        "&PALAVRASN1=%s" \
-        "&FILTRON1=%s" \
-        "&ESTRUTN1=0301&ORDEMN2=E"
-
-      def initialize
-        super("Siciliano", "Livraria Siciliano (Brasil)")
-        # no preferences for the moment
-        prefs.read
-      end
-
-      def get_book_from_search_result(result)
-        log.info { "Fetching book from #{result[:url]}" }
-        html_data = transport.get(URI.parse(result[:url]))
-        parse_result_data(html_data, result)
-      end
-
-      def search(criterion, type)
-        criterion = criterion.encode("ISO-8859-1") # still needed??
-        trying_again = false
-        begin
-          req = create_search_uri(type, criterion, trying_again)
-          log.debug { "#{name} #{trying_again ? 'retrying ' : ''}request = #{req}" }
-          data = transport.get(URI.parse(req))
-          results = parse_search_result_data(data)
-          raise NoResultsError if results.empty?
-
-          if type == SEARCH_BY_ISBN
-            get_book_from_search_result(results.first)
-          else
-            results.map { |result| get_book_from_search_result(result) }
-          end
-        rescue NoResultsError => ex
-          if (type == SEARCH_BY_ISBN) && (trying_again == false)
-            trying_again = true
-            retry
-          else
-            raise ex
-          end
-        end
-      end
-
-      # the new Siciliano website no longer has direct links to books by their ISBN
-      # (the permalink now seems to be based on the product id)
-      def url(_book)
-        nil
-      end
-
-      private
-
-      def create_search_uri(search_type, search_term, trying_again = false)
-        (search_type_code = { SEARCH_BY_ISBN    => "G",
-                              SEARCH_BY_TITLE   => "A",
-                              SEARCH_BY_AUTHORS => "B",
-                              SEARCH_BY_KEYWORD => "X" }[search_type]) || "X"
-        search_term_encoded = if search_type == SEARCH_BY_ISBN
-                                if trying_again
-                                  # on second attempt, try ISBN-10...
-                                  Library.canonicalise_isbn(search_term) # isbn-10
-                                else
-                                  # search by ISBN-13 first
-                                  Library.canonicalise_ean(search_term) # isbn-13
-                                end
-                              else
-                                CGI.escape(search_term)
-                              end
-
-        format(BASE_SEARCH_URL, search_term_encoded, search_type_code)
-      end
-
-      def parse_search_result_data(html)
-        # The layout...
-        # td[@class="normal"]
-        #   span[@class="vitrine_nome_produto"]
-        #      a (title and link to 'product page')
-        #   br
-        #   TEXT --> author / publisher
-        #   br
-        #   div[@class="vitrine_preco_por"] (price info)
-
-        doc = html_to_doc(html)
-        book_search_results = []
-        # each result will be a dict with keys :title, :author, :publisher, :url
-
-        list_items = doc.search("div.pesquisa-item-lista-conteudo")
-        list_items.each do |item|
-          result = {}
-
-          # author & publisher
-          author_publisher = ""
-          item.children.each do |node|
-            author_publisher += node.to_s if node.text?
-            author_publisher.strip!
-            break unless author_publisher.empty?
-          end
-          author, publisher = author_publisher.split("/")
-          result[:author] = author.strip if author
-          result[:publisher] = publisher.strip if publisher
-
-          # title & url
-          link = item % "a"
-          result[:title] = link.inner_text.strip
-          link_to_description = link["href"]
-          slash = ""
-          slash = "/" unless %r{^/}.match?(link_to_description)
-          result[:url] = "#{SITE}#{slash}#{link_to_description}"
-
-          book_search_results << result
-        rescue StandardError => ex
-          trace = ex.backtrace.join("\n> ")
-          log.error { "Failed parsing Siciliano search page #{ex.message}\n#{trace}" }
-        end
-
-        book_search_results
-      end
-
-      def parse_result_data(html, search_result)
-        # checked against Siciliano website 21 Feb 2009
-        doc = html_to_doc(html)
-        # title
-        title_div = doc % "div#conteudo//div.titulo"
-        raise NoResultsError unless title_div
-
-        title_h = title_div % "h2"
-        title = title_h.inner_text if title_h
-        # title = first_non_empty_text_node(title_div)
-        # author_spans = doc/'span.rotulo'
-        author_hs = title_div / "h3.autor"
-        authors = []
-        author_hs.each do |h|
-          authors << h.inner_text.strip
-        end
-        ## synopsis_div = doc % 'div#sinopse'
-        details_div = doc % "div#tab-caracteristica"
-        details = string_array_to_map(lines_of_text_as_array(details_div))
-        # ISBN
-        isbn =  details["ISBN"]
-        ## ean = details["CdBarras"]
-        translator = details["Tradutor"]
-        authors << translator if translator
-        binding = details["Acabamento"]
-        publisher = search_result[:publisher]
-        # publish year
-        publish_year = nil
-        edition = details["Edio"]
-        # publication date
-        publish_year = Regexp.last_match[1].to_i if edition && edition =~ /([12][0-9]{3})/
-        # cover
-        # ImgSrc[1]="/imagem/imagem.dll?pro_id=1386929&PIM_Id=658849";
-        image_urls = []
-        (doc / "script").each do |script|
-          next if script.children.nil?
-
-          script.children.each do |ch|
-            ch_text = ch.to_s
-            if ch_text =~ /ImgSrc\[[\d]\]="(.+)";/
-              img_link = Regexp.last_match[1]
-              image_urls << img_link
-            end
-          end
-        end
-        book = Book.new(title, authors, isbn, publisher, publish_year, binding)
-        result = [book, image_urls.first]
-        result
-      rescue StandardError => ex
-        trace = ex.backtrace.join("\n> ")
-        log.error { "Failed parsing Siciliano product page #{ex.message}\n#{trace}" }
-        nil
-      end
-
-      def first_non_empty_text_node(elem)
-        text = ""
-        elem.children.each do |node|
-          next unless node.text?
-
-          text = node.to_s.strip
-          break unless text.empty?
-        end
-        text
-      end
-
-      def lines_of_text_as_array(elem)
-        lines = []
-        current_text = ""
-        elem.children.each do |e|
-          if e.text?
-            current_text += e.to_s
-          elsif e.name == "br"
-            lines << current_text.strip
-            current_text = ""
-          else
-            current_text += e.inner_text
-          end
-        end
-        lines << current_text.strip
-        lines.delete("")
-        lines
-      end
-
-      def string_array_to_map(arr)
-        map = {}
-        arr.each do |str|
-          key, val = str.split(":")
-          # a real hack for not handling encoding properly :^)
-          map[key.gsub(/[^a-zA-Z]/, "")] = val.strip if val
-        end
-        map
-      end
-
-      # def binding_type(binding) # portuguese string
-      #  {"brochura" => :paperback,
-      #    "encadernado" => :hardback}[binding.downcase] or :unknown
-      # end
-    end
-  end
-end