lbp 0.0.1

data/lib/lbp/item_group.rb

@@ -0,0 +1,52 @@
+require 'nokogiri'
+require 'rugged'
+require 'lbp/functions'
+require 'lbp/transcription'
+
+module Lbp
+	class ItemGroup
+		attr_reader :igid
+		
+		def initialize(projectfile, igid)
+      @igid = igid
+      @projectfile = projectfile
+      
+    end
+
+    def items
+			file = Nokogiri::XML(File.read(@projectfile))
+			result = file.xpath("//div[@id='#{@igid}']//item/fileName/@filestem")
+			fs_array = result.map do |fs| 
+				Item.new(@projectfile, fs.value)
+			end
+			return fs_array
+		end
+		def item(fs)
+			Item.new(@projectfile, fs)
+		end
+		def title
+			file = Nokogiri::XML(File.read(@projectfile))
+			result = file.xpath("//div[@id='#{@igid}']/head")
+			return result.text
+		end
+		def has_sub_group?
+			file = Nokogiri::XML(File.read(@projectfile))
+			result = file.xpath("//div[@id='#{@igid}']//div")
+			if result.count == 0
+				false
+			else
+				true
+			end
+		end
+		def has_parent_group?
+			#I sort of hate this method. But it sort of works, though I can imagine problems.
+			file = Nokogiri::XML(File.read(@projectfile))
+			result = file.xpath("//div[@id='#{@igid}'][@class='toplevel']")
+			if result.count == 0
+				true
+			else
+				false
+			end
+		end
+	end
+end

data/lib/lbp/paragraph.rb

@@ -0,0 +1,87 @@
+require 'nokogiri'
+require 'rugged'
+require 'lbp/functions'
+
+module Lbp
+	class Paragraph
+		attr_reader :pid 
+		def initialize(projectfile, filehash, pid)
+			
+			@projectfile = projectfile
+			@filehash = filehash
+			@pid = pid
+			
+			@confighash = Collection.new(@projectfile)
+	  end
+
+	  def number
+	  	transcr = Transcription.new(@projectfile, @filehash)
+	  	totalparagraphs = transcr.number_of_body_paragraphs
+	  	xmlobject = transcr.nokogiri
+	  	paragraphs_following = xmlobject.xpath("//tei:body//tei:p[preceding::tei:p[@xml:id='#{@pid}']]", 'tei' => 'http://www.tei-c.org/ns/1.0').count
+	  	paragraph_number = totalparagraphs - paragraphs_following
+	  	
+			return paragraph_number
+	  end
+	  def next
+	  	xmlobject = Transcription.new(@projectfile, @filehash).nokogiri
+	  	nextpid = xmlobject.xpath("//tei:p[@xml:id='#{@pid}']/following::tei:p[1]/@xml:id", 'tei' => 'http://www.tei-c.org/ns/1.0')
+			if nextpid.text == nil
+        return nil
+      else
+				return Paragraph.new(@projectfile, @filehash, nextpid.text)
+      end
+	  end
+	  def previous
+	  	xmlobject = Transcription.new(@projectfile, @filehash).nokogiri
+	  	previouspid = xmlobject.xpath("//tei:p[@xml:id='#{@pid}']/preceding::tei:p[1]/@xml:id", 'tei' => 'http://www.tei-c.org/ns/1.0')
+	  	if previouspid.empty?
+        return nil
+      else
+				return Paragraph.new(@projectfile, @filehash, previouspid.text)
+      end
+	  end
+	  def transform(xsltfile, xslt_param_array=[])
+	  	result = Transcription.new(@projectfile, @filehash).transform(xsltfile, xslt_param_array)
+			p = result.xpath("//p[@id='#{@pid}']")
+			return p
+		end
+		def transform_plain_text(xslt_param_array=[])
+			# not that it could be slightly confusing that paragraph plain text uses the transform clean,
+			# because we still the basic paragraph elements in order to select the desired paragraph
+			result = Transcription.new(@projectfile, @filehash).transform_clean(xslt_param_array)
+			
+			p = result.xpath("//p[@id='#{@pid}']")
+			return p
+		end
+		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='frequency', order='descending')
+    	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

data/lib/lbp/transcription.rb

@@ -0,0 +1,249 @@
+require 'nokogiri'
+require 'rugged'
+require 'lbp/functions'
+require 'lbp/item'
+require 'open-uri'
+
+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
+	  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
+	end
+end

data/lib/lbp/version.rb

@@ -0,0 +1,3 @@
+module Lbp
+  VERSION = "0.0.1"
+end

data/spec/collection_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'lbp'
+require 'pry'
+require 'nokogiri'
+
+describe 'collection object' do 
+	require_relative "config_globals"
+	
+	$collection_obj = Lbp::Collection.new($pg_projectfile)
+
+	it 'should get list of item filestems in sequenced array' do 
+		result = $collection_obj.item_filestems
+		expect(result).to be_kind_of(Array)
+ 	end
+ 	it 'should get a list of item names in sequenced array' do 
+ 		result = $collection_obj.item_titles
+ 		expect(result).to be_kind_of(Array)
+ 	end
+ 	it 'should return a hash of filestems and item names' do 
+		result = $collection_obj.items_fs_title_hash
+		expect(result).to be_kind_of(Hash)
+	end
+
+
+
+	it 'should get list of item objects in an array' do
+ 		result = $collection_obj.items
+ 		#reunning result.first.title returns ERROR!!!
+ 		expect(result).to be_kind_of(Array)
+	end
+
+	it 'should return local texts dir' do 
+		result = $collection_obj.local_texts_dir
+		expect(result).to be_kind_of(String)
+	end
+
+	it 'should return general repo directory' do 
+		result = $collection_obj.git_repo
+		
+		expect(result).to be_kind_of(String)
+	end
+	it 'should return citation lists directory' do 
+		result = $collection_obj.citation_lists_dir
+		expect(result).to be_kind_of(String)
+	end
+	it 'should return xslt hash' do 
+		result = $collection_obj.xslt_dirs
+		expect(result).to be_kind_of(Hash)
+	end
+	it 'should return a specific item object when a specific item group id is given' do
+		result = $collection_obj.item('lectio1')
+		expect(result).to be_kind_of(Lbp::Item)
+	end
+	it 'should return the title of a given collection specified in the project data file' do 
+		result = $collection_obj.title
+		expect(result).to be_kind_of(String)
+	end
+	
+	
+end