perseus 0.0.1

data/exe/homer

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+#/ Usage: <homer> (-iliad or -odyssey) [options]...
+#/ Fetch content from homers epics by book and line
+# ** Tip: use #/ lines to define the --help usage message.
+$stderr.sync = true
+require 'optparse'
+require 'pry'
+require 'ox'
+require 'awesome_print'
+require 'roman-numerals'
+require 'net/http'
+require 'uri'
+
+# default options
+ILIAD = 1
+ODYSSEY = 2
+options = {
+  title: nil,
+  translate: false,
+  language: "grc", #or "eng" or "lat"
+  books: [1],#[1, 21, 13]
+  lines: [1]#[1, 108, 257]
+}
+# parse arguments
+file = __FILE__
+optparse = OptionParser.new do |opts|
+  opts.on("-translate", "--translate") {
+    options[:translate] = true
+  }
+  opts.on("-iliad", "--iliad") {
+    options[:title] = ILIAD
+  }
+  opts.on("-odyssey", "--odyssey") {
+    options[:title] = ODYSSEY
+  }
+  opts.on("-lang", "--language=val", String) { |val|
+    options[:language] = val
+  }
+  opts.on("-b", "--book=val", Integer) { |val|
+    options[:books] = [val]
+  }
+  opts.on("-l", "--line=val", Integer) { |val|
+    options[:lines] = [val]
+  }
+  opts.on("--books=[x,y,z]", Array) { |val|
+    options[:books] = val
+  }
+  opts.on("--lines=[x,y,z]", Array) { |val|
+    options[:lines] = val
+  }
+  opts.on_tail("-h", "--help") {
+    exec "grep ^#/<'#{file}'|cut -c4-"
+  }
+end
+optparse.parse!
+
+raise "Please provide the title of the work you are looking for -> odyssey or iliad".red if options[:title].nil?
+
+def open(url)
+  Net::HTTP.get(URI.parse(url))
+end
+
+def fetch_stanzas title, language, books, lines
+  books.each do |book|
+    lines.each do |line|
+      ctsurl_pfx = "http://www.perseus.tufts.edu/hopper/CTS?request="
+      node_urn = "urn:cts:greekLit:tlg0012.tlg00#{title}.perseus-#{language}1:#{book}.#{line}"
+      book = node_urn.split(":").last.split(".")[0]
+      passage_url = "#{ctsurl_pfx}GetPassage&urn=#{node_urn}"
+      passage_xml = open(passage_url)
+      passage_content = Ox.parse(passage_xml)
+      begin
+        line_content = passage_content.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].nodes[1]
+        if line_content.nil?
+          line_content = passage_content.nodes[0].nodes[1].nodes[0].nodes[0].nodes[0].nodes[0].nodes[0]
+        end
+        puts "#{RomanNumerals.to_roman(book.to_i).cyan}\t#{line.to_s.yellow}: #{line_content.green}"
+      rescue Exception => e
+        if e.message == "undefined method `nodes' for \"3\":String"
+          puts "language: #{language}, book: #{RomanNumerals.to_roman(book.to_i)}, line: #{line} missing?".red
+        else
+          puts e
+        end
+      end
+    end
+  end
+end
+
+fetch_stanzas options[:title], options[:language], options[:books], options[:lines]

data/exe/perseus

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+require 'pp'
+require 'awesome_print'
+require 'perseus'
+require 'perseus/network_index_xml'
+require 'perseus/file_index_xml'
+
+class OptparseExample
+  Version = Perseus::VERSION
+  class ScriptOptions
+    attr_accessor :query,
+                  :search_by,
+                  :verbose
+    def initialize
+      self.query = nil
+      self.search_by = "group"
+      self.verbose = false
+    end
+
+    def define_options(parser)
+      parser.banner = "Usage: perseus [options]"
+      parser.separator ""
+      parser.separator "Specific options:"
+
+      # add additional options
+      generate_index(parser)
+      search_a_word(parser)
+      get_passage_valid_references(parser)
+      get_passage(parser)
+      search_by_title_option(parser)
+      search_by_group_option(parser)
+      boolean_verbose_option(parser)
+
+      parser.separator ""
+      parser.separator "Common options:"
+      # No argument, shows at tail.  This will print an options summary.
+      # Try it and see!
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+      # Another typical switch to print the version.
+      parser.on_tail("--version", "Show version") do
+        puts Version
+        exit
+      end
+    end
+
+    def generate_index(parser)
+            #Optional '--type' option argument with keyword completion.
+      parser.on("--generate_json []", [:network, :local],
+                "Generates the perseus indeces in json format choose fetch method (network -> download, save and index from network, local -> index from already downloaded xml file)") do |source|
+        Perseus::NetworkIndexXML.new.generate_json_indeces if source.eql? :network
+        Perseus::FileIndexXML.new.generate_json_indeces if source.eql? :local
+        exit
+      end
+    end
+
+    def search_a_word(parser)
+      parser.on("--word WORD", "Search ancient greek or latin word") do |word|
+        w = Perseus::Dictionary.new(word)
+        puts JSON.pretty_generate(w.to_h)
+        exit
+      end
+    end
+
+    def get_passage_valid_references(parser)
+      parser.on("--valid_refs URN", "Get valid urn's to query passage content") do |urn|
+        refs = Perseus::CorpusReferences.new(urn)
+        reference_links = refs.to_h["GetValidReff"]["reply"]["reff"]["urn"]
+        puts "You are about to get a list of valid references for this passage"
+        puts "Are you sure you want the all printed on the screen?".red
+        puts "Answering anything but yes will only print the first 10 references".yellow
+        print_all = gets
+        if print_all.eql? "yes"
+          reference_links.each { |link|  puts link.cyan }
+        else
+          reference_links.each_with_index { |link, i| puts link.cyan if i < 10 }
+        end
+        #.map { |e|
+          #e.split(":").last
+        #}
+        exit
+      end
+    end
+
+    def get_passage(parser)
+      parser.on("--passage URN", "Get passage content for given urn") do |urn|
+        passage = Perseus::Passage.new(urn)
+        puts JSON.pretty_generate(passage.to_h)
+        exit
+      end
+    end
+
+    def search_by_title_option(parser)
+      parser.on("--title TITLE", "Search by title") do |query|
+        self.search_by = "label"
+        self.query = query
+      end
+    end
+
+    def search_by_group_option(parser)
+      parser.on("--author GROUPNAME/AUTHOR", "Search by groupname/author") do |query|
+        self.search_by = "groupname"
+        self.query = query
+      end
+    end
+
+    def boolean_verbose_option(parser)
+      # Boolean switch.
+      parser.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        self.verbose = v
+      end
+    end
+  end
+
+  def parse(args)
+    @options = ScriptOptions.new
+    @args = OptionParser.new do |parser|
+      @options.define_options(parser)
+      parser.parse!(args)
+    end
+    @options
+  end
+
+  attr_reader :parser, :options
+end
+
+options = OptparseExample.new.parse(ARGV)
+unless options.query.nil?
+  texts = Perseus::Corpora.new.all.deep_locate -> (key, value, object) {
+    key == options.search_by && value.include?(options.query)
+  }
+  puts "Found #{texts.size} editions matching your query: #{options.query}"
+  Perseus.print_editions texts
+end

data/lib/perseus.rb

@@ -0,0 +1,14 @@
+# perseus api
+require 'pathname'
+require "perseus/version"
+require "perseus/constants"
+require "perseus/helpers"
+require "perseus/corpus_hash"
+require 'perseus/corpora'
+require 'perseus/corpus_references'
+require 'perseus/dictionary'
+require 'perseus/passage'
+
+module Perseus
+  # Extra or cool stuff here
+end

data/lib/perseus/constants.rb

@@ -0,0 +1,7 @@
+module Perseus
+  CTS_PFX = "http://www.perseus.tufts.edu/hopper/CTS?request="
+  DATA_DIR = Pathname.new(__FILE__).join("../../../data")
+  CTS_XML_FILE = "#{DATA_DIR}/perseus-index.xml"
+  CTS_BY_GROUP_JSON_FILE = "#{DATA_DIR}/perseus-index-by-group.json"
+  ALL_EDITIONS_JSON = "#{DATA_DIR}/perseus-index-by-edition.json"
+end

data/lib/perseus/corpora.rb

@@ -0,0 +1,17 @@
+require 'json'
+require 'hashie'
+require 'perseus/corpus_hash'
+
+module Perseus
+  class Corpora
+    def initialize
+      @elements = JSON.parse(File.read(Perseus::ALL_EDITIONS_JSON)).map do |e|
+        Perseus::CorpusHash.new e
+      end
+      @elements.extend(Hashie::Extensions::DeepLocate)
+    end
+    def all
+      @elements
+    end
+  end
+end

data/lib/perseus/corpus_hash.rb

@@ -0,0 +1,22 @@
+require 'hashie'
+module Perseus
+  class CorpusHash < Hash
+    include Hashie::Extensions::MergeInitializer
+    include Hashie::Extensions::IndifferentAccess
+    include Hashie::Extensions::MethodAccess
+    include Hashie::Extensions::Coercion
+    coerce_value Hash, CorpusHash
+    def initialize(hash = {})
+      super
+      hash.each_pair do |k,v|
+        if v.kind_of?(Array)
+          self[k] = v.map { |v_i| CorpusHash.new(v_i) }
+        elsif v.kind_of?(Hash)
+          self[k] = CorpusHash.new v
+        else
+          self[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/perseus/corpus_references.rb

@@ -0,0 +1,8 @@
+require 'perseus/cts_element'
+module Perseus
+  class CorpusReferences < CTSElement
+    def initialize urn
+      @urn = "#{CTS_PFX}GetValidReff&urn=#{urn}"
+    end
+  end
+end

data/lib/perseus/cts_element.rb

@@ -0,0 +1,19 @@
+require 'json'
+require 'active_support'
+require 'active_support/core_ext'
+require 'net/http'
+require 'uri'
+module Perseus
+  class CTSElement
+    attr_reader :to_s, :to_h, :to_json
+    def to_s
+      @to_s ||= Net::HTTP.get(URI.parse(@urn))
+    end
+    def to_h
+      @to_h ||= Hash.from_xml(to_s)
+    end
+    def to_json
+      @to_json ||= to_h.to_json
+    end
+  end
+end

data/lib/perseus/dictionary.rb

@@ -0,0 +1,8 @@
+require 'perseus/cts_element'
+module Perseus
+  class Dictionary < CTSElement
+    def initialize word
+      @urn = "http://www.perseus.tufts.edu/hopper/xmlmorph?lang=greek&lookup=#{word}"
+    end
+  end
+end

data/lib/perseus/file_index_xml.rb

@@ -0,0 +1,12 @@
+require 'perseus/index_xml'
+module Perseus
+  class FileIndexXML < IndexXML
+    def initialize
+      puts "Reading from locally saved xml"
+      @urn = CTS_XML_FILE
+    end
+    def to_s
+      @to_s ||= File.read(@urn)
+    end
+  end
+end

data/lib/perseus/helpers.rb

@@ -0,0 +1,62 @@
+module Perseus
+  def self.print_editions editions
+    editions.each do |edition|
+      print_corpus_info edition.groupname, edition.type, edition.label, edition.urn, edition.language.green, edition.description
+    end
+  end
+  def self.print_corpus texts
+    texts.each do |t|
+      groupname = t.groupname
+      t.work.each_with_index do |work, i|
+        begin
+          # Check if we have many editions
+          unless work["edition"].nil?
+            language = work["xml:lang"]
+            if work.edition.kind_of?(Array)
+              work.edition.each do |edition|
+                title = edition.label
+                urn = edition.urn
+                desc = edition.description
+                print_corpus_info groupname, "edition", title, urn, language.green, desc
+              end
+            else
+              title = work.title
+              urn = work.edition.urn
+              desc = work.edition.description
+              print_corpus_info groupname, "edition", title, urn, language.green
+            end
+          end
+          # Check to see if we have translations
+          unless work["translation"].nil?
+            # Check if we have many translations
+            if work.translation.kind_of?(Array)
+              work.translation.each do |translation|
+                title = translation.label
+                urn = translation.urn
+                language = translation["xml:lang"]
+                print_corpus_info groupname, "translation", title, urn, language.redish
+              end
+            else
+              title = work.title
+              urn = work.translation.urn
+              language = work.translation["xml:lang"]
+              print_corpus_info groupname, "translation", title, urn, language.redish
+            end
+          end
+        rescue Exception => e
+          puts "exception: #{e.message.red}"
+          #puts "Stack trace: #{backtrace.map {|l| "  #{l}\n"}.join}"
+          puts "We were working in group: #{groupname.cyan} with the following data point:".green
+          puts work.inspect.yellow
+        end
+      end
+    end
+  end
+
+  def self.print_corpus_info groupname, type, title, urn, language, description = nil
+    puts "#{groupname} - #{title.purple}: #{urn.yellow}, #{type}: #{language}"
+    unless description.nil?
+      puts description.cyan
+    end
+  end
+end

data/lib/perseus/index_xml.rb

@@ -0,0 +1,97 @@
+require 'awesome_print'
+require 'perseus/corpus_hash'
+require 'perseus/cts_element'
+module Perseus
+  class IndexXML < CTSElement
+    attr_reader :corpus_by_groupname, :corpus_by_edition
+    def by_groupname
+      @corpus_by_groupname ||= generate_structure_by_group
+    end
+    def by_edition
+      @corpus_by_edition ||= generate_structure_by_edition
+    end
+
+    def generate_structure_by_group
+      to_h["TextInventory"]["textgroup"].map do |text|
+        CorpusHash.new text
+      end.map do |t|
+        tmp_hash = CorpusHash.new
+        t.work.each_with_index do |work, i|
+          if work.kind_of?(Array)
+            # This is a special kind of array and we need to make
+            # it adhere to our protocol
+            tmp_hash[work[0]] = work[1]
+            #puts work.inspect
+            #puts tmp_hash
+            if t.work.size - 1 == i
+              t.work = [tmp_hash]
+              tmp_hash = CorpusHash.new
+            end
+          end
+        end && t
+      end
+    end
+
+    def generate_structure_by_edition
+      new_corpus = []
+      corpus_by_groupname.each do |t|
+        groupname = t.groupname
+        t.work.each_with_index do |work, i|
+          begin
+            # Check if we have many editions
+            unless work["edition"].nil?
+              if work.edition.kind_of?(Array)
+                work.edition.each do |edition|
+                  new_corpus.push(CorpusHash.new({
+                    groupname: groupname,
+                    language: work["xml:lang"],
+                    type: "edition",
+                  }).merge(edition))
+                end
+              else
+                new_corpus.push(CorpusHash.new({
+                  groupname: groupname,
+                  language: work["xml:lang"],
+                  type: "edition",
+                }).merge(work.edition))
+              end
+            end
+            # Check to see if we have translations
+            unless work["translation"].nil?
+              # Check if we have many translations
+              if work.translation.kind_of?(Array)
+                work.translation.each do |translation|
+                  new_corpus.push(CorpusHash.new({
+                    groupname: groupname,
+                    language: translation["xml:lang"],
+                    type: "edition",
+                  }).merge(translation))
+                end
+              else
+                new_corpus.push(CorpusHash.new({
+                  groupname: groupname,
+                  language: work.translation["xml:lang"],
+                  type: "edition",
+                }).merge(work.translation))
+              end
+            end
+          rescue Exception => e
+            puts "exception: #{e.message.red}"
+            #puts "Stack trace: #{backtrace.map {|l| "  #{l}\n"}.join}"
+            puts "We were working in group: #{groupname.cyan} with the following data point:".green
+            puts work.inspect.yellow
+          end
+        end
+      end
+      new_corpus
+    end
+
+    def generate_json_indeces
+      puts "Generating index by groupname"
+      File.write(Perseus::CTS_BY_GROUP_JSON_FILE, JSON.pretty_generate(by_groupname))
+      puts "Generating index by edition"
+      File.write(Perseus::ALL_EDITIONS_JSON, JSON.pretty_generate(by_edition))
+      puts "DONE".green
+    end
+  end
+end