lbp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be83290049ce0d3c203adf4e3ff2139a709ab72c
-  data.tar.gz: cfdfe9478a8f86ddd3e381c391cfc97142241f45
+  metadata.gz: 5c8f418230bba408ab7abcc2bfc63535ce44a425
+  data.tar.gz: 89cb6d564dfd559786f940882b168ee20deab8b5
 SHA512:
-  metadata.gz: cc21ee397365f89a2194178c533d36fe42d91bebf472561234002a8a9e9e84ca3b61553daa12baf4a5aad9f55f78edbaadf5950e1ffd58cae52e8b1a253d6fe9
-  data.tar.gz: 0eb62da1320ecb9377ff83a5ce4fa3369117fa510af19c5160580823dcf0e00940b8f39750c5d2eddbddf28c9b9dd377143fad7e6ed2b31a9946f9b507b3ad31
+  metadata.gz: 4f0cc56d0015815ac15c2e71e801afb290e3958205a0205c9b0160139e1c918a39aa6278e611b1f8f4f13b5931f1bd2f289b8c58cdb665b5de25afed919a89dd
+  data.tar.gz: dae6f816869aeeeb625a89c5eaffd4153c63ab071d79ed585611e3f8e293e0ef867461ac0d9ec5cb21ca1a378f4906cc8cac65bd1658aa1607b76b7b38f3ef7d

data/lib/lbp.rb

@@ -1,7 +1,7 @@
 require "lbp/version"
 
   require 'lbp/functions'
- 
+
 #still need review
   require 'lbp/query'
   require 'lbp/paragraph_image'
@@ -9,13 +9,13 @@ require "lbp/version"
 
 #new files
   require 'lbp/resource'
+  require 'lbp/work_group'
   require 'lbp/expression'
+  require 'lbp/expression_type'
   require 'lbp/manifestation'
+  require 'lbp/translation'
   require 'lbp/transcription'
   require 'lbp/file'
   require 'lbp/file_part'
-
-  
-  
-
-
+  require 'lbp/article'
+  require 'lbp/resource_identifier'

data/lib/lbp/article.rb

@@ -0,0 +1,36 @@
+require 'openssl'
+require 'rdf'
+require 'rdf/rdfxml'
+require 'rdf/ntriples'
+require 'rdf/vocab'
+require 'lbp'
+
+module Lbp
+	class Article < Resource
+		#initionalization handled by Resource Class
+		def file_path
+			file_path = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/hasXML")).first[:o].to_s
+		end
+	  def article_type
+	  	type = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/articleType")).first[:o].to_s
+	  	type.downcase
+	  end
+	  def article_type_shortId
+	  	self.article_type.split("/").last
+	  end
+
+	  #TODO: if the file object became more abstract the file operations could handle both transcriptions and articles
+	  #Otherwise there should be a class called articleFile and transcriptionFile that inherits from generic File.
+	  #def file(confighash)
+	  #	file = File.new(self.file_path, self.transcription_type, confighash)
+	  #	return file
+	  #end
+	  #NOTE: this really is a temporary method, since the database 
+	  #should point to file corresponding to each transcription
+	  #dynamically generated by the exist-db database.
+	  # but this could remain in case it was useful to grab the part 
+	  # from a file that would include a tei header etc.
+	  
+	  #end
+	end
+end

data/lib/lbp/expression.rb

@@ -6,157 +6,102 @@ 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
+
+		def structure_type #returns resource identifier 
+			value("http://scta.info/property/structureType")
 		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
+		def manifestations # returns array of available manifestations as ResourceIdentifiers
+			values("http://scta.info/property/hasManifestation")
 		end
-		def transcriptionUrl(manifestationUrl)
-			manifestationObj = Manifestation.new(manifestationUrl)
-			transcriptionObj = manifestationObj.canonicalTranscriptionUrl 
-			return transcriptionObj
+		def canonical_manifestation # returns a single manifestation ResourceIdentifier
+			value("http://scta.info/property/hasCanonicalManifestation")
 		end
-		def transcription(manifestationUrl)
-			manifestationObj = Manifestation.new(manifestationUrl)
-			transcriptionObj = manifestationObj.canonicalTranscription 
-			return transcriptionObj
+		def canonical_manifestation? # returns boolean
+			!canonical_manifestation.to_s.nil?
 		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
+		# translations are a subclass of manifestations for any kind of manifestation not in the original language
+		# note that this currently means the manifestations methods, will not grab translation-manifestations, 
+		# these must be called with translations method
+		def translations
+			values("http://scta.info/property/hasTranslation")
 		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
+		def canonical_translation
+			values("http://scta.info/property/hasCanonicalTranslation")
+		end
+		def canonical_translation?
+			!canonical_translation.to_s.nil?
+		end
+		# cannonical transcriptions refers to the canonical trancription of the canonical manifestation
+		def canonical_transcription # returns single transcription as ResourceIdentifier
+			manifestation = canonical_manifestation
+			unless manifestation == nil
+				return manifestation.resource.canonical_transcription
 			end
-			return previous_expression
 		end
-		def order_number
+		def canonical_transcription? #returns boolean
+			!canonical_transcription.nil?
+		end
+		
+		def next # returns resource identifier of next expression or nil
+			value("http://scta.info/property/next")
+		end
+		def previous #returns ResourceIdentifier or nil
+			value("http://scta.info/property/previous")
+		end
+		def order_number # returns integer
 			## 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
+			if structure_type.short_id == "structureBlock"
+				value("http://scta.info/property/paragraphNumber").to_s.to_i
 			else
-				ordernumber = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/totalOrderNumber")).first[:o].to_s.to_i
+				value("http://scta.info/property/totalOrderNumber").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
+		def status #returns string
+			value("http://scta.info/property/status").to_s
 		end
-
-		def top_level_expression_url
+		def top_level_expression # returns resource identifier
 			#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
+			value("http://scta.info/property/isPartOfTopLevelExpression")
 		end
-		def top_level_expression
-			expression = Expression.new(self.top_level_expression_url)
-		end
-
-		def item_level_expression_url
+		def item_level_expression # returns resource identifier
 			#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
+			value("http://scta.info/property/isPartOfStructureItem")
 		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
+		def level # returns resource integer
+			#same comment as earlier; this query does not actually return a uri, 
+			#but an litteral. We need to make sure the resource identifer can handle that
+			value("http://scta.info/property/level").to_s.to_i
 		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"))
+		def abbreviates # returns array of ResourceIdentifiers
+			values("http://scta.info/property/abbreviates")
     end
     def abbreviatedBy
-    	abbreviatedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/abbreviatedBy"))
+    	values("http://scta.info/property/abbreviatedBy")
     end
     def references
-    	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/references"))
+    	values("http://scta.info/property/references")
     end
     def referencedBy
-    	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/referencedBy"))
+    	values("http://scta.info/property/referencedBy")
     end
     def copies
-    	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copies"))
+    	values("http://scta.info/property/copies")
     end
     def copiedBy
-    	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copiedBy"))
+    	values("http://scta.info/property/copiedBy")
     end
     def mentions
-    	mentions = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/mentions"))
+    	values("http://scta.info/property/mentions")
     end
     def quotes
-    	quotes = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotes"))
+    	values("http://scta.info/property/quotes")
     end
     def quotedBy
-    	quotedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotedBy"))
+    	values("http://scta.info/property/quotedBy")
     end
 
 	end

data/lib/lbp/expression_type.rb

@@ -0,0 +1,5 @@
+module Lbp
+	class ExpressionType < Resource
+		
+	end
+end

data/lib/lbp/file.rb

@@ -6,45 +6,69 @@ require 'lbp'
 
 module Lbp
 	# class should be renamed to Transcription
-	class File 
+	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
+			unless confighash == nil
+				@stylesheets = @confighash[:stylesheets]
+				# identify propery xslt directory
+			end
 
-		  #xslt version needs to gathered from a method
-		  xslt_version = nil
-		  #for now its being set to nil because no documents currently declare it
+			# get trancription type from xmlfile
+		  @transcription_type = transcription_type # critical or documentary # there is also a method for this if one needs to get the type from the file itself
 
-	    if xslt_version == nil
-	    	@schema = @xslthash["default"]
-	   	else
-	    	@schema = @xslthash[xslt_version]
-	    end
+		  # get xslt_version from xmlfile
+		  @xslt_version = self.validating_schema_version
+
+			unless confighash == nil
+				@xslt_dir = "#{@confighash[:xslt_base]}#{@xslt_version}/#{@transcription_type}/"
+			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]]})
+			file = open(self.file_path)
+	    if file.base_uri.to_s != self.file_path
+	        file = open(self.file_path, {:http_basic_authentication => [@confighash[:git_username], @confighash[:git_password]]})
+	    end
 			return file
 		end
 		def nokogiri
 			xmldoc = Nokogiri::XML(self.file)
 		end
 		## End File Path Methods
+
+		## Get transcription type
+		def transcription_type_from_file
+			xmldoc = self.nokogiri
+
+			result = xmldoc.xpath("/tei:TEI/tei:text[1]/@type", 'tei' => 'http://www.tei-c.org/ns/1.0')
+
+			if result.length > 0
+				return result.to_s
+			else
+				return "unknown"
+			end
+
+		end
+		## get validating schema label
+		def validating_schema_version
+			xmldoc = self.nokogiri
+			result = xmldoc.xpath("/tei:TEI/tei:teiHeader[1]/tei:encodingDesc[1]/tei:schemaRef[1]/@n", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			if result.length > 0
+				return result.to_s.split("-").last
+			else
+				return "default"
+			end
+		end
+
+		def transcription_type
+
+		end
 		### Item Header Extraction and Metadata Methods
 		def title
 			xmldoc = self.nokogiri
@@ -72,9 +96,13 @@ module Lbp
 			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
+			if self.validating_schema_version == "1.0.0"
+				return "no pub date in this schema"
+			else
+				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
 		end
 		def encoding_method
 			xmldoc = self.nokogiri
@@ -89,7 +117,7 @@ module Lbp
 		def number_of_columns
 			xmldoc = self.nokogiri
 			test = xmldoc.xpath("//tei:pb", 'tei' => 'http://www.tei-c.org/ns/1.0')
-			if @type == "critical"
+			if @transcription_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
@@ -107,35 +135,35 @@ module Lbp
 			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"
+			xsltfile=@xslt_dir + @stylesheets[: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"
+			xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[: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"
+    	xsltfile=@xslt_dir + @stylesheets[:toc] # "lectio_outline.xsl"
     	doc = self.transform_apply(xsltfile, xslt_param_array)
     end
     ### End of Transformation Methods ###
@@ -153,8 +181,8 @@ module Lbp
     	word_array = self.word_array
     	wf = Hash.new(0)
 			word_array.each { |word| wf[word] += 1 }
-			
-			if sort == "frequency" 
+
+			if sort == "frequency"
 				if order == "descending" # high to low
 					wf = wf.sort_by{|k,v| v}.reverse
 				elsif order == "ascending" # low to high
@@ -170,4 +198,4 @@ module Lbp
 			return wf.to_h
     end
   end
-end
+end