lbp 0.0.2 → 0.1.0

data/lib/lbp/transcription.rb

@@ -1,249 +1,33 @@
-require 'nokogiri'
-require 'rugged'
-require 'lbp/functions'
-require 'lbp/item'
-require 'open-uri'
+require 'openssl'
+require 'rdf'
+require 'rdf/rdfxml'
+require 'rdf/ntriples'
+require 'rdf/vocab'
+require 'lbp'
 
 module Lbp
-	class Transcription 
-		attr_reader :fs, :type, :ed, :xslt_dir
-
-		def initialize(projectfile, filehash)
-
-				@filehash = filehash
-	      @projectfile = projectfile
-
-	      @fs = filehash[:fs]
-	      @type = filehash[:type] # critical or documentary
-	      @ed = filehash[:ed]
-	      
-	      @confighash = Collection.new(@projectfile).confighash
-	      @xslthash = @confighash[:xslt_dirs]
-	      
-	      #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'
-		      	@xslt_dir = @schema[:critical]
-	      elsif @type == 'documentary'
-		      	@xslt_dir = @schema[:documentary]
-      	end
-	      	
-
-	      if @filehash[:source] == 'local'
-	      	item = Item.new(@projectfile, @fs)
-  				@current_branch = item.git_current_branch
-  			# the effort here is to only set instance variable when absolutely necessary
-  				if @current_branch != @ed
-  					@item = item
-  			end
-  		end
+	class Transcription < 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 transcription_type
+	  	type = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/transcriptionType")).first[:o].to_s
+	  	type.downcase
 	  end
-	  ## Begin file path methods
-	  # Returns the absolute path of the file requested
-	  def file_path
-	  	@filehash[:path]
-		end
-		def file
-
-			file = open(self.file_path)
-		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 - I think these methods belong with the Item or ItemRepo Object
-
-    ### End Header and Metadata Information Extraction Methods ###
-   	### Begin GIT functions ###
-  	def is_git_dir
-  		gitpath = @file_dir + ".git"
-  		
-  		if File.directory?(gitpath) 
-  			true
-  		else
-  			false
-  		end
-  	end
-  	def git_branches
-  		repo = Rugged::Repository.new(@file_dir)
-  		branches = repo.branches.map { |branch| branch.name }
-		return branches
-		end
-		def git_current_branch
-  		repo = Rugged::Repository.new(@file_dir)
-  		current_branch = repo.head.name.gsub(%r!\Arefs/heads/(.*)\z!) { $1 }
-  		return current_branch
-  	end
-  	def git_tags
-  		repo = Rugged::Repository.new(@file_dir)
-  		tags = repo.tags.map { |tag| tag.name }
-		return tags
-  	end
-  	#need test for this 
-  	def git_checkout(branch)
-  		repo = Rugged::Repository.new(@file_dir)
-  		repo.checkout(branch)
-		end
-		### End Git Methods ###
-=end		
-		### Begin transform (XSLT) methocs ###
-		def transform(xsltfile, xslt_param_array=[])
-
-  		xmlfile = self.file_path
-			if @current_branch != @ed && @filehash[:source] == 'local'
-      	@item.git_checkout(@ed)
-      		doc = xslt_transform(xmlfile, xsltfile, xslt_param_array)
-      	@item.git_checkout(@current_branch);
-      else
-      	doc = xslt_transform(xmlfile, xsltfile, xslt_param_array)
-      end
-		end
-
-		def transform_main_view(xslt_param_array=[])
-			xsltfile=@xslt_dir + @schema[:main_view] # "text_display.xsl"
-			doc = self.transform(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( xsltfile, xslt_param_array=[])
-		end
-		def transform_clean(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(xsltfile, xslt_param_array=[])
-    end
-    def transform_toc(xslt_param_array=[])
-    	xsltfile=@xslt_dir + @schema[:toc] # "lectio_outline.xsl"
-    	doc = self.transform(xsltfile, xslt_param_array=[])
-    end
-    ### End of Transformation Methods ###
-    ### Begin Statistics Methods ###
-    def word_count
-    	plaintext = self.transform_plain_text
-    	size = plaintext.text.split.size
-    end
-    def word_array
-    	plaintext = self.transform_plain_text
-    	word_array = plaintext.text.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
-    def number_of_body_paragraphs
-			if @current_branch != @ed && @filehash[:source] == 'local'
-  				@item.git_checkout(@ed)
-      			xmldoc = self.nokogiri
-						p = xmldoc.xpath("//tei:body//tei:p", 'tei' => 'http://www.tei-c.org/ns/1.0')
-      		@item.git_checkout(@current_branch);
-      else
-      		xmldoc = self.nokogiri
-					p = xmldoc.xpath("//tei:body//tei:p", 'tei' => 'http://www.tei-c.org/ns/1.0')
-      end
-      return p.count
-		end
-		def paragraphs
-			## it's not good to keep reusing this, git check out condition. Need a better solution
-			if @current_branch != @ed && @filehash[:source] == 'local'
-  				@item.git_checkout(@ed)
-      			xmldoc = self.nokogiri
-						paragraphs = xmldoc.xpath("//tei:body//tei:p/@xml:id", 'tei' => 'http://www.tei-c.org/ns/1.0')
-      		@item.git_checkout(@current_branch);
-      else
-      		xmldoc = self.nokogiri
-					paragraphs = xmldoc.xpath("//tei:body//tei:p/@xml:id", 'tei' => 'http://www.tei-c.org/ns/1.0')
-      end
-
-      paragraph_objects = paragraphs.map do |p| Paragraph.new(@projectfile, @filehash, p.value) end
-      
-      return paragraph_objects
-		end
-		def paragraph(pid)
-			Paragraph.new(@projectfile, @filehash, pid)
-		end
+	  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.
+	  def file_part(confighash, partid)
+	  	file = FilePart.new(self.file_path, self.transcription_type, confighash, partid)
+	  	return file
+	  end
 	end
 end

data/lib/lbp/version.rb

@@ -1,3 +1,3 @@
 module Lbp
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/config_globals.rb

@@ -1,18 +1,33 @@
-$confighash = { texts_dir: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projecfiles/GitTextfiles/", 
-		projectdatafile_dir: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/Conf/", 
-		xslt_critical_dir: "/Users/JCWitt/WebPages/lbpwrapper/lombardpress/public/pl_xslt_stylesheets/",
-		xslt_documentary_dir: "/Users/JCWitt/WebPages/lbpwrapper/lombardpress/public/pl_xslt_stylesheets/", 
-		xslt_main_view: "text_display.xsl",
-		xslt_index_view: "text_display_index.xsl", 
-		xslt_clean: "clean_forStatistics.xsl",
-		xslt_plain_text: "plaintext.xsl", 
-		xslt_toc: "lectio_outline.xsl", 
-		git_repo: "bitbucket.org/jeffreycwitt/"}
+$confighash = {local_texts_dir: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/GitTextfiles/", 
+							citation_lists_dir: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/citationlists/", 
+							xslt_dirs: { "default" => {
+								critical: "/Users/jcwitt/Projects/lombardpress/lombardpress2/xslt/default/critical/",
+								documentary: "/Users/jcwitt/Projects/lombardpress/lombardpress2/xslt/default/documentary/", 
+								main_view: "main_view.xsl",
+								clean_view: "clean_view.xsl",
+								plain_text: "plaintext.xsl", 
+								toc: "lectio_outline.xsl"
+									}
+								},
+							git_repo: "bitbucket.org/jeffreycwitt/",
+							git_username: ENV["GUN"],
+							git_password: ENV["GPW"]
+						}
 
+		
 
-#filehash = {path: "https://bitbucket.org/jeffreycwitt/lectio1/raw/master/lectio1.xml", fs: "lectio1", ed: "master", type: "critical", source: "origin"}
-$filehash = {path: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/GitTextfiles/lectio1/lectio1.xml", fs: "lectio1", ed: "master", type: "critical", source: "local"}
+
+#$filehash = {path: "https://bitbucket.org/jeffreycwitt/lectio1/raw/master/reims_lectio1.xml", fs: "lectio1", ed: "master", type: "documentary", source: "origin"}
+$filehash = {path: "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/GitTextfiles/lectio1/lectio1.xml", fs: "lectio1", ed: "master", type: "critical", source: "local", commentary_id: "plaoulcommentary"}
 
 $projectfile = "/Users/JCWitt/WebPages/lbplib-testfiles/pp-projectfiles/Conf/projectdata.xml"
 
-$pg_projectfile = "/Users/JCWitt/WebPages/lbplib-testfiles/pg-projectfiles/Conf/projectdata.xml"
+$pg_projectfile = "/Users/JCWitt/WebPages/lbplib-testfiles/pg-projectfiles/Conf/projectdata.xml"
+
+$auto_pp_projectfile = "/Users/JCWitt/WebPages/lbp.rb/pp-projectfiles/Conf/projectfile.xml"
+
+$scta_url = "http://scta.info/text/plaoulcommentary/item/lectio1"
+#$scta_url = "http://localhost:4567/text/plaoulcommentary/item/lectio1"
+
+$commentary_url = "http://scta.info/text/plaoulcommentary/commentary"
+#$commentary_url = "http://scta.info/text/wodehamordinatio/commentary"

data/spec/expression_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'lbp'
+require 'pry'
+
+
+describe 'expression object' do 
+	#TODO: database needs be changed so that shortID is "sententia"
+	$resource_obj1 = Lbp::Expression.new("sentences")
+	$resource_obj2 = Lbp::Expression.new("http://scta.info/resource/sententia")
+	$resource_item = Lbp::Expression.new("lectio1")
+	$resource_toplevelexpression = Lbp::Expression.new("plaoulcommentary")
+	$resource_itemFirstInSequence = Lbp::Expression.new("principiumI")
+	$resource_itemLastInSequence = Lbp::Expression.new("lectio134")
+	$resource_item2 = Lbp::Expression.new("pl-l1d1c1") #structureItem id
+	$resource_item3 = Lbp::Expression.new("http://scta.info/resource/l1-acfefv") #paragraph url
+	$resource_para = Lbp::Expression.new("l1-acfefv") #paragraph id
+	$resource_div1 = Lbp::Expression.new("wdr-l1d1q1") #div short id
+	$resource_div2 = Lbp::Expression.new("http://scta.info/resource/wdr-l1d1q1") #div url
+	
+	it 'returns array of manifestations for given expression at the structureItem level' do 
+		result = $resource_item.manifestationUrls
+		expect(result).to be_kind_of(Array)
+ 	end
+ 	it 'returns array of manifestations for given expression structureBlock level' do 
+		result = $resource_para.manifestationUrls
+		expect(result).to be_kind_of(Array)
+ 	end
+ 	it 'returns type of resource id from url to check inheritance from Resource Class' do 
+		result = $resource_item.type_shortId
+		expect(result).to be == "expression"
+ 	end
+ 	it 'returns canonical manifestation' do 
+		result = $resource_item.canonicalManifestationUrl
+		expect(result).to be == "http://scta.info/resource/lectio1/critical"
+ 	end
+ 	it 'returns canonical transcription' do 
+		result = $resource_item.canonicalTranscriptionUrl
+		expect(result).to be == "http://scta.info/resource/lectio1/critical/transcription"
+	end
+	it 'returns true or false for presence of canonical Transcription' do 
+		result = $resource_item.canonicalTranscription?
+		expect(result).to be == true
+	end
+	it 'returns false for presence of canonical Transcription' do 
+		$resource_without_transcript_started = Lbp::Expression.new("b3-q2")
+		result = $resource_without_transcript_started.canonicalTranscription?
+		expect(result).to be == false
+	end
+	
+	it 'returns status of expression' do 
+		result = $resource_item.status
+	
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns next expression at the same (structureItem) level' do 
+		result = $resource_item.next
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns null for expression next request when expression is last in the series' do 
+		result = $resource_itemLastInSequence.next
+		expect(result).to be == nil
+	end
+	it 'returns previous expression at the same (structureItem) level' do 
+		result = $resource_item.previous
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns null for expression previous request when expression is first in the series' do 
+		result = $resource_itemLastInSequence.next
+		expect(result).to be == nil
+	end
+	it 'returns next expression at the same (structureBlock) level' do 
+		result = $resource_para.next
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns previous expression at the same (structureBlock) level' do 
+		result = $resource_para.previous
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns top level expression for expression resource' do 
+		result = $resource_para.top_level_expression_url
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns top level expression for expression resource' do 
+		result = $resource_item.top_level_expression_url
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns top level expression for expression resource' do 
+		result = $resource_item.top_level_expression_shortId
+		expect(result).to be_kind_of(String)
+	end
+	it 'returns the level integer from the expression' do 
+		result = $resource_toplevelexpression.level
+		expect(result).to be_kind_of(Integer)
+	end
+
+end

data/spec/file_part_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'lbp'
+require 'pry'
+require 'nokogiri'
+
+describe 'file_part object' do
+		
+		require_relative "config_globals"
+		paragraph1 = "l1-cpspfs"
+		paragraph3 = "l1-shoatd"
+		
+		$paragraph = Lbp::FilePart.new("https://bitbucket.org/jeffreycwitt/lectio1/raw/master/lectio1.xml", "critical", $confighash, paragraph1)
+		$div = Lbp::FilePart.new("https://bitbucket.org/jeffreycwitt/lectio1/raw/master/lectio1.xml", "critical", $confighash, paragraph1)
+		$topdiv = Lbp::FilePart.new("https://bitbucket.org/jeffreycwitt/lectio1/raw/master/lectio1.xml", "critical", $confighash, "lectio1")
+
+	it 'should return the pid for the Paragraph object' do 
+		result = $paragraph.partid
+		
+		expect(result).to be_kind_of(String)
+	end
+	# it 'should return the number of the paragraph number' do 
+	# 	result = $paragraph.number
+	# 	expect(result).to be_kind_of(Integer)
+	# end
+	it 'should return the next paragraph object or nil if there are no more paragraphs' do
+		result = $paragraph.next
+		expect(result).to be_kind_of(Lbp::FilePart)
+	end
+	it 'should return the previous paragraph object or nil if there are no more paragraphs' do
+		result = $paragraph.previous
+		#this test works but I don't know how to write a test matching object or nil
+		#expect(result).to be(Lbp::Paragraph || nil) 
+	end
+	it 'should return the plain text of the paragraph as a nokogiri object' do 
+		result = $paragraph.transform_plain_text
+		expect(result).to be_instance_of(Nokogiri::XML::NodeSet)
+	end
+	#it 'should return the plain text of the paragraph as a nokogiri object' do 
+	#	result = $paragraph.transform_main_view
+	#	expect(result).to be_instance_of(Nokogiri::XML::NodeSet)
+	#end
+	it 'should return the plain text of the topdiv as a nokogiri object' do 
+		result = $topdiv.transform_plain_text
+		expect(result).to be_instance_of(Nokogiri::XML::NodeSet)
+	end
+	it 'it should return the paragragraph as TEI XML an nokogiri node set' do 
+		result = $paragraph.xml
+		expect(result).to be_instance_of(Nokogiri::XML::NodeSet)
+	end
+	it 'it should return element name of element with xmlid' do
+		result = $paragraph.element_name
+		expect(result).to be_kind_of(String)
+	end
+	
+end