lbp 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d49f877ac5360958e5c62b4701c97b2a897112be
-  data.tar.gz: 3fc110f62a9545f20785e8b8b01d609c7ab12e68
+  metadata.gz: be83290049ce0d3c203adf4e3ff2139a709ab72c
+  data.tar.gz: cfdfe9478a8f86ddd3e381c391cfc97142241f45
 SHA512:
-  metadata.gz: 4113fffbc328ab020d952eb88dfaf2ebe01bd12abdc929473052f3b2d307b606f00536702b87c45a68b2d1f36c98df5c5c20d268cd5bb54178079b2ba23f740a
-  data.tar.gz: d2d3535865aaf51cfd8abd3af442bc2d6b830a2f2c97419ad5416c6ed1fe0e9acd4ae10be71140197eed348cd00f30d956b6a4f18177ec89ea7d2abcc44010f8
+  metadata.gz: cc21ee397365f89a2194178c533d36fe42d91bebf472561234002a8a9e9e84ca3b61553daa12baf4a5aad9f55f78edbaadf5950e1ffd58cae52e8b1a253d6fe9
+  data.tar.gz: 0eb62da1320ecb9377ff83a5ce4fa3369117fa510af19c5160580823dcf0e00940b8f39750c5d2eddbddf28c9b9dd377143fad7e6ed2b31a9946f9b507b3ad31

data/.gitignore

@@ -12,4 +12,8 @@
 *.o
 *.a
 mkmf.log
+/projectfiles/
+/pp-projectfiles/
+/pg-projectfiles/
+/aw-projectfiles/
 

data/.ruby-gemset

@@ -1 +1 @@
-lbp
+default

data/.ruby-version

@@ -1 +1 @@
-ruby-2.2.0
+ruby-2.2.1

data/bin/lbp

@@ -65,7 +65,7 @@ class LbpCli < Thor
 
     itemarray << headerdata
 
-    data.query(:predicate => RDF::DC.hasPart).each do |part|
+    data.query(:predicate => RDF::URI.new("http://scta.info/property/hasItem")).each do |part|
       
       newresource = RDF::Resource.new(part.object)
       newgraph = RDF::Graph.load(newresource)
@@ -78,13 +78,44 @@ class LbpCli < Thor
 
       unless status == 'Not Started'
         title = newdata.query(:predicate => RDF::DC11.title).first.object
+        if newdata.query(:predicate => RDF::URI.new("http://scta.info/property/questionTitle")).count == 0
+          question_title = "unknown"
+        else
+          question_title = newdata.query(:predicate => RDF::URI.new("http://scta.info/property/questionTitle")).first.object
+        end
         id = URI(part.object.to_s).path.split('/').last
         itemunit = "
         <item live='#{status}'>
           <fileName filestem='#{id}'>#{id}.xml</fileName>
           <title>#{title}</title>
-        </item>\n"
+          <questionTitle>#{question_title}</questionTitle>"
         itemarray << itemunit
+        #eventually hasPart property should be sctap:hasTranscription
+          hastranscriptions = newdata.query(:predicate => RDF::DC.hasPart) 
+          if hastranscriptions.count > 0 
+            partunitopen = "\n<hasParts>"
+            itemarray << partunitopen
+            hastranscriptions.each do |transcription|
+              transcription_resource = RDF::Resource.new(transcription.object)
+              transcription_graph = RDF::Graph.load(transcription_resource)
+              transcription_data = transcription_graph.data
+              transcription_title = transcription_data.query(:predicate => RDF::DC11.title).first.object
+              transcription_id = URI(transcription.object.to_s).path.split('/').last
+              transcription_slug = transcription_id.split("_").first
+              transcription_initial = transcription_slug.each_char.first.upcase # not ideal, some initials will be two letters
+              partunit = "\n<part>
+                <slug>#{transcription_slug}</slug>
+                <title>#{transcription_title}</title>
+                <initial>#{transcription_initial}</initial>
+              </part>"
+              itemarray << partunit
+            end
+            partunitclose = "\n</hasParts>"
+            itemarray << partunitclose
+          end
+         #end
+        close_item_unit = "\n</item>\n"
+        itemarray << close_item_unit
       end
        
     end

data/lbp.gemspec

@@ -23,14 +23,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
   spec.add_runtime_dependency "nokogiri"
-  spec.add_runtime_dependency "rugged"
+  #spec.add_runtime_dependency "rugged"
   spec.add_runtime_dependency "thor"
   spec.add_runtime_dependency "rdf"
   spec.add_runtime_dependency "rdf-rdfxml"
+  spec.add_runtime_dependency "rdf-vocab"
   spec.add_runtime_dependency "rest-client"
+  spec.add_runtime_dependency "sparql"
 
 
-
-
-  
 end

data/lib/lbp.rb

@@ -1,11 +1,21 @@
 require "lbp/version"
 
+  require 'lbp/functions'
+ 
+#still need review
+  require 'lbp/query'
+  require 'lbp/paragraph_image'
 
-	require 'lbp/functions'
-  require 'lbp/item'
-  require 'lbp/paragraph'
+
+#new files
+  require 'lbp/resource'
+  require 'lbp/expression'
+  require 'lbp/manifestation'
   require 'lbp/transcription'
-	require 'lbp/item_group'
-  require 'lbp/collection'
+  require 'lbp/file'
+  require 'lbp/file_part'
+
+  
+  
 
 

data/lib/lbp/expression.rb

@@ -0,0 +1,163 @@
+require 'openssl'
+require 'rdf'
+require 'rdf/rdfxml'
+require 'rdf/ntriples'
+require 'rdf/vocab'
+require 'lbp'
+
+
+
+
+module Lbp
+	class Expression < Resource 
+		
+		#inherits initialization from Resource
+		
+		def manifestationUrls
+			results = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/hasManifestation"))
+			manifestations = results.map {|m| m[:o].to_s}
+			return manifestations
+		end
+		def canonicalManifestationUrl
+			manifestation = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/hasCanonicalManifestation")).first[:o].to_s
+			return manifestation
+		end
+		def canonicalManifestation
+			url = self.canonicalManifestationUrl
+			manifestationObj = Manifestation.new(url)
+			return manifestationObj
+		end
+		def canonicalManifestation?
+			if self.canonicalManifestationUrl == nil
+				return false
+			else
+				return true
+			end
+		end
+		# cannonical transcriptions refers to the canonical trancription 
+		# of the canonical manifestation
+		def canonicalTranscriptionUrl
+			manifestationObj = self.canonicalManifestation
+			url = manifestationObj.canonicalTranscriptionUrl
+			return url
+		end
+		def canonicalTranscription
+			url = self.canonicalTranscriptionUrl
+			transcriptionObj = Transcription.new(url)
+			return transcriptionObj
+		end
+		def canonicalTranscription?
+			if self.canonicalManifestation? == false
+				return false
+			else
+				if self.canonicalTranscriptionUrl == nil
+					return false
+				else
+					return true
+				end
+			end
+		end
+		def transcriptionUrl(manifestationUrl)
+			manifestationObj = Manifestation.new(manifestationUrl)
+			transcriptionObj = manifestationObj.canonicalTranscriptionUrl 
+			return transcriptionObj
+		end
+		def transcription(manifestationUrl)
+			manifestationObj = Manifestation.new(manifestationUrl)
+			transcriptionObj = manifestationObj.canonicalTranscription 
+			return transcriptionObj
+		end
+		def next
+			unless self.results.dup.filter(:p => RDF::URI("http://scta.info/property/next")).count == 0
+				next_expression = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/next")).first[:o].to_s
+			else
+				next_expression = nil
+			end
+			return next_expression
+		end
+		def previous
+			unless self.results.dup.filter(:p => RDF::URI("http://scta.info/property/previous")).count == 0
+				previous_expression = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/previous")).first[:o].to_s
+			else
+				previous_expression = nil
+			end
+			return previous_expression
+		end
+		def order_number
+			## TODO: consider changing property so that there is more symmetry here
+			if self.structureType_shortId == "structureBlock"
+				ordernumber = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/paragraphNumber")).first[:o].to_s.to_i
+			else
+				ordernumber = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/totalOrderNumber")).first[:o].to_s.to_i
+			end
+			return ordernumber
+		end
+		def status
+			status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/status")).first[:o].to_s
+		end
+
+		def top_level_expression_url
+			#TODO make sure this can handle different structure types
+			status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/isPartOfTopLevelExpression")).first[:o].to_s
+		end
+		def top_level_expression_shortId
+			self.top_level_expression_url.split("/").last
+		end
+		def top_level_expression
+			expression = Expression.new(self.top_level_expression_url)
+		end
+
+		def item_level_expression_url
+			#TODO make sure this can handle different structure types
+			status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/isPartOfStructureItem")).first[:o].to_s
+		end
+		def item_level_expression_shortId
+			self.item_level_expression_url.split("/").last
+		end
+		def item_level_expression
+			expression = Expression.new(self.item_level_expression_url)
+		end
+		def level
+			result = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/level")).first[:o]
+			unless self.results.count == 0 
+				level = result.to_s.to_i
+			else
+				level = nil
+			end
+			return level
+		end
+		
+		# connection properties
+		#TODO: notice how all these return RDF::Solutions (or some RDF:: object)
+		# rather already performing the conversion to strings as is done in all the above methods
+		# this should be standardized
+		def abbreviates
+    	abbreviates = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/abbreviates"))
+    end
+    def abbreviatedBy
+    	abbreviatedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/abbreviatedBy"))
+    end
+    def references
+    	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/references"))
+    end
+    def referencedBy
+    	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/referencedBy"))
+    end
+    def copies
+    	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copies"))
+    end
+    def copiedBy
+    	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copiedBy"))
+    end
+    def mentions
+    	mentions = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/mentions"))
+    end
+    def quotes
+    	quotes = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotes"))
+    end
+    def quotedBy
+    	quotedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotedBy"))
+    end
+
+	end
+end

data/lib/lbp/file.rb

@@ -0,0 +1,173 @@
+require 'nokogiri'
+#require 'lbp/functions'
+#require 'lbp/item'
+require 'open-uri'
+require 'lbp'
+
+module Lbp
+	# class should be renamed to Transcription
+	class File 
+		attr_reader :xslt_dir, :file_path
+
+		def initialize(filepath, transcription_type, confighash)
+			@file_path = filepath
+			@confighash = confighash
+			@xslthash = @confighash[:xslt_dirs]
+
+		  @type = transcription_type # critical or documentary
+
+		  #xslt version needs to gathered from a method
+		  xslt_version = nil
+		  #for now its being set to nil because no documents currently declare it
+
+	    if xslt_version == nil
+	    	@schema = @xslthash["default"]
+	   	else
+	    	@schema = @xslthash[xslt_version]
+	    end
+
+	    if @type == 'critical' || @type == 'Critical'
+	    	@xslt_dir = @schema[:critical]
+	    elsif @type == 'documentary' || @type == 'Documentary' || @type == 'diplomatic'
+	    	@xslt_dir = @schema[:documentary]
+	  	end
+	  end
+		
+		def file
+			#TODO: needs to be written so auth is only need after request without
+			#auth is rejected
+			
+			#file = open(self.file_path)
+			file = open(self.file_path, {:http_basic_authentication => [@confighash[:git_username], @confighash[:git_password]]})
+			return file
+		end
+		def nokogiri
+			xmldoc = Nokogiri::XML(self.file)
+		end
+		## End File Path Methods
+		### Item Header Extraction and Metadata Methods
+		def title
+			xmldoc = self.nokogiri
+			title = xmldoc.xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc[1]/tei:titleStmt[1]/tei:title[1]", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return title.text
+		end
+		def author
+			xmldoc = self.nokogiri
+			author = xmldoc.xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc/tei:titleStmt[1]/tei:author", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return author.text
+		end
+		def editor
+			xmldoc = self.nokogiri
+			editor = xmldoc.xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc/tei:titleStmt[1]/tei:editor", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return editor.text
+		end
+		def ed_no
+			xmldoc = self.nokogiri
+			ed_no = xmldoc.at_xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc[1]/tei:editionStmt[1]/tei:edition[1]/@n", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return ed_no.value
+		end
+		def ed_date
+			xmldoc = self.nokogiri
+			ed_date = xmldoc.at_xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc[1]/tei:editionStmt[1]/tei:edition[1]/tei:date[1]/@when", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return ed_date.value
+		end
+		def pub_date
+			xmldoc = self.nokogiri
+			pub_date = xmldoc.at_xpath("/tei:TEI/tei:teiHeader[1]/tei:fileDesc[1]/tei:publicationStmt[1]/tei:date[1]/@when", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return pub_date.value
+		end
+		def encoding_method
+			xmldoc = self.nokogiri
+			encoding_method = xmldoc.at_xpath("/tei:TEI/tei:teiHeader[1]/tei:encodingDesc[1]/tei:variantEncoding[1]/@method", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return encoding_method.value
+		end
+		def encoding_location
+			xmldoc = self.nokogiri
+			encoding_location = xmldoc.at_xpath("/tei:TEI/tei:teiHeader[1]/tei:encodingDesc[1]/tei:variantEncoding[1]/@location", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			return encoding_location.value
+		end
+		def number_of_columns
+			xmldoc = self.nokogiri
+			test = xmldoc.xpath("//tei:pb", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			if @type == "critical"
+				number_of_columns = nil
+			elsif xmldoc.xpath("//tei:pb", 'tei' => 'http://www.tei-c.org/ns/1.0').count != 0
+            number_of_columns = 1
+      elsif xmldoc.xpath("//tei:cb", 'tei' => 'http://www.tei-c.org/ns/1.0').count != 0
+           	number_of_columns = 2
+      end
+      return number_of_columns
+    end
+
+		### Begin transform (XSLT) methocs ###
+		def transform(xsltfile, xslt_param_array=[])
+			doc = xslt_transform(self.nokogiri, xsltfile, xslt_param_array)
+    end
+		def transform_apply(xsltfile, xslt_param_array=[])
+			doc = xslt_apply_to(self.nokogiri, xsltfile, xslt_param_array)
+    end
+    def transform_main_view(xslt_param_array=[])
+			xsltfile=@xslt_dir + @schema[:main_view] # "text_display.xsl"
+			doc = self.transform_apply(xsltfile, xslt_param_array)
+		end
+		def transform_index_view(xslt_param_array=[])
+			xsltfile=@xslt_dir + @schema[:index_view] # "text_display_index.xsl"
+			doc = self.transform_apply(xsltfile, xslt_param_array)
+		end
+		def transform_clean(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:clean_view] # "clean_forStatistics.xsl"
+    	doc = self.transform_apply(xsltfile, xslt_param_array)
+    end
+    def transform_clean_nokogiri(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:clean_view] # "clean_forStatistics.xsl"
+    	doc = self.transform(xsltfile, xslt_param_array)
+    end
+		def transform_plain_text(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:plain_text] # "plaintext.xsl"
+    	doc = self.transform_apply(xsltfile, xslt_param_array)
+    end
+    def transform_plain_text_nokogiri(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:plain_text] # "plaintext.xsl"
+    	doc = self.transform(xsltfile, xslt_param_array)
+    end
+    def transform_json(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:json] # "plaintext.xsl"
+    	doc = self.transform_apply(xsltfile, xslt_param_array)
+    end
+    def transform_toc(xslt_param_array=[])
+    	xsltfile=@xslt_dir + @schema[:toc] # "lectio_outline.xsl"
+    	doc = self.transform_apply(xsltfile, xslt_param_array)
+    end
+    ### End of Transformation Methods ###
+    ### Begin Statistics Methods ###
+    def word_count
+    	plaintext = self.transform_plain_text
+    	size = plaintext.split.size
+    end
+    def word_array
+    	plaintext = self.transform_plain_text
+    	word_array = plaintext.split
+    	word_array.map!{ |word| word.downcase}
+    end
+    def word_frequency(sort, order)
+    	word_array = self.word_array
+    	wf = Hash.new(0)
+			word_array.each { |word| wf[word] += 1 }
+			
+			if sort == "frequency" 
+				if order == "descending" # high to low
+					wf = wf.sort_by{|k,v| v}.reverse
+				elsif order == "ascending" # low to high
+					wf = wf.sort_by{|k,v| v}
+				end
+			elsif sort == "word"
+				if order == "descending" # z - a
+						wf = wf.sort_by{|k,v| k}.reverse
+				elsif order == "ascending" #a - z
+						wf = wf.sort_by{|k,v| k}
+				end
+			end
+			return wf.to_h
+    end
+  end
+end