rwdgutenberg 0.12 → 0.13

data/lib/marc/writer.rb

@@ -0,0 +1,87 @@
+module MARC
+
+  # A class for writing MARC records as MARC21.
+
+  class Writer
+
+    # the constructor which you must pass a file path
+    # or an object that responds to a write message
+
+    def initialize(file)
+      if file.class == String
+        @fh = File.new(file,"w")
+      elsif file.respond_to?('write')
+        @fh = file
+      else
+        throw "must pass in file name or handle"
+      end
+    end
+
+
+    # write a record to the file or handle
+
+    def write(record)
+      @fh.write(MARC::Writer.encode(record))
+    end
+
+
+    # close underlying filehandle
+
+    def close
+      @fh.close
+    end
+
+
+    # a static method that accepts a MARC::Record object
+    # and returns the record encoded as MARC21 in transmission format
+
+    def self.encode(record)
+      directory = ''
+      fields = ''
+      offset = 0
+      for field in record.fields
+
+        # encode the field
+        field_data = ''
+        if field.class == MARC::DataField 
+          field_data = field.indicator1 + field.indicator2 
+          for s in field.subfields
+            field_data += SUBFIELD_INDICATOR + s.code + s.value
+          end
+        elsif field.class == MARC::ControlField
+          field_data = field.value
+        end
+        field_data += END_OF_FIELD
+
+        # calculate directory entry for the field
+        field_length = field_data.length()
+        directory += sprintf("%03s%04i%05i", field.tag, field_length, 
+          offset)
+
+        # add field to data for other fields
+        fields += field_data 
+
+        # update offset for next field
+        offset += field_length
+      end
+
+      # determine the base (leader + directory)
+      base = record.leader + directory + END_OF_FIELD
+
+      # determine complete record
+      marc = base + fields + END_OF_RECORD
+
+      # update leader with the byte offest to the end of the directory
+      marc[12..16] = sprintf("%05i", base.length())
+
+      # update the record length
+      marc[0..4] = sprintf("%05i", marc.length())
+      
+      # store updated leader in the record that was passed in
+      record.leader = marc[0..LEADER_LENGTH-1]
+
+      # return encoded marc
+      return marc 
+    end
+  end
+end

data/lib/marc/xmlreader.rb

@@ -0,0 +1,103 @@
+require 'rexml/document'
+require 'rexml/parsers/pullparser'
+
+module MARC
+  
+  class XMLReader
+    include Enumerable
+
+    # the constructor which you can pass either a filename:
+    #
+    #   reader = MARC::XMLReader.new('/Users/edsu/marc.xml')
+    #
+    # or a File object, 
+    #
+    #   reader = Marc::XMLReader.new(File.new('/Users/edsu/marc.xml'))
+    #
+    # or really any object that responds to read(n)
+    # 
+    #   reader = MARC::XMLReader.new(StringIO.new(xml))
+ 
+    def initialize(file)
+      if file.class == String:
+        handle = File.new(file)
+      elsif file.respond_to?("read", 5)
+        handle = file
+      else
+        throw "must pass in path or File"
+      end
+
+      @parser = REXML::Parsers::PullParser.new(handle)
+    end
+
+    def each
+      while @parser.has_next?
+        event = @parser.pull
+        # if it's the start of a record element 
+        if event.start_element? and strip_ns(event[0]) == 'record'
+          yield build_record
+        end
+      end
+    end
+
+    private
+
+    def strip_ns(str)
+      return str.sub(/^.*:/, '')
+    end
+
+    # will accept parse events until a record has been built up
+    #
+    def build_record
+      record = MARC::Record.new
+      data_field = nil
+      control_field = nil
+      subfield = nil
+      text = '' 
+      attrs = nil
+
+      while @parser.has_next?
+        event = @parser.pull
+
+        if event.text?
+          text += REXML::Text::unnormalize(event[0])
+          next
+        end
+
+        if event.start_element?
+          text = ''
+          attrs = event[1]
+          case strip_ns(event[0])
+          when 'controlfield'
+            text = ''
+            control_field = MARC::ControlField.new(attrs['tag'])
+          when 'datafield'
+            text = ''
+            data_field = MARC::DataField.new(attrs['tag'], attrs['ind1'], 
+              attrs['ind2'])
+          when 'subfield'
+            text = ''
+            subfield = MARC::Subfield.new(attrs['code'])
+          end
+        end
+
+        if event.end_element?
+          case strip_ns(event[0])
+          when 'leader'
+            record.leader = text
+          when 'record'
+            return record
+          when 'controlfield'
+            control_field.value = text
+            record.append(control_field)
+          when 'datafield'
+            record.append(data_field)
+          when 'subfield'
+            subfield.value = text
+            data_field.append(subfield)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marc/xmlwriter.rb

@@ -0,0 +1,155 @@
+require 'rexml/document'
+require 'rexml/text'
+require 'rexml/formatters/default'
+
+module MARC
+  
+  # A class for writing MARC records as MARCXML.
+  # BIG CAVEAT! XMLWriter will *not* convert your MARC8 to UTF8
+  # bug the authors to do this if you need it
+  
+  class XMLWriter
+    
+    # the constructor which you must pass a file path
+    # or an object that responds to a write message
+    # the second argument is a hash of options, currently
+    # only supporting one option, stylesheet
+    # 
+    # writer = XMLWriter.new 'marc.xml', :stylesheet => 'style.xsl'
+    # writer.write record
+    
+    def initialize(file, opts={})
+      @writer = REXML::Formatters::Default.new
+      if file.class == String
+        @fh = File.new(file,"w")
+      elsif file.respond_to?('write')
+        @fh = file
+      else
+        throw "must pass in file name or handle"
+      end
+      
+      @fh.write("<?xml version='1.0'?>\n")
+      if opts[:stylesheet]
+        @fh.write(
+          %Q{<?xml-stylesheet type="text/xsl" href="#{opts[:stylesheet]}"?>\n})
+      end
+      @fh.write("<collection xmlns='" + MARC_NS + "' " +
+        "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' " +
+        "xsi:schemaLocation='" + MARC_NS + " " + MARC_XSD + "'>")
+      @fh.write("\n")
+    end
+    
+    
+    # write a record to the file or handle
+    
+    def write(record)
+      @writer.write(MARC::XMLWriter.encode(record), @fh)
+      @fh.write("\n")
+    end
+    
+    
+    # close underlying filehandle
+    
+    def close
+      @fh.write("</collection>")
+      @fh.close
+    end
+
+    
+    # a static method that accepts a MARC::Record object
+    # and returns a REXML::Document for the XML serialization.
+
+    def self.encode(record, opts={})
+      singleChar = Regexp.new('[\da-z ]{1}')
+      ctrlFieldTag = Regexp.new('00[1-9A-Za-z]{1}')
+      
+      # Right now, this writer handles input from the strict and
+      # lenient MARC readers. Because it can get 'loose' MARC in, it
+      # attempts to do some cleanup on data values that are not valid
+      # MARCXML.
+      
+      # TODO? Perhaps the 'loose MARC' checks should be split out
+      # into a tolerant MARCXMLWriter allowing the main one to skip
+      # this extra work.
+      
+      # TODO: At the very least there should be some logging
+      # to record our attempts to account for less than perfect MARC.
+      
+      e = REXML::Element.new('record')
+      e.add_namespace(MARC_NS) if opts[:include_namespace]
+
+      # MARCXML only allows alphanumerics or spaces in the leader
+      record.leader.gsub!(/[^\w|^\s]/, 'Z')
+      
+      # MARCXML is particular about last four characters; ILSes aren't
+      if (record.leader[20..23] != "4500")
+        record.leader[20..23] = "4500"
+      end
+
+      # MARCXML doesn't like a space here so we need a filler character: Z
+      if (record.leader[6..6] == " ")
+        record.leader[6..6] = "Z"
+      end
+      
+      leader = REXML::Element.new("leader")
+      leader.add_text(record.leader)
+      e.add_element(leader)
+      
+      for field in record.fields
+        if field.class == MARC::DataField 
+          datafield_elem = REXML::Element.new("datafield")
+          
+          # If marc is leniently parsed, we may have some dirty data; using
+          # the 'z' ind1 value should help us locate these later to fix
+          if (field.indicator1.match(singleChar) == nil)
+            field.indicator1 = 'z'
+          end
+          
+          # If marc is leniently parsed, we may have some dirty data; using
+          # the 'z' ind2 value should help us locate these later to fix
+          if (field.indicator2.match(singleChar) == nil)
+            field.indicator2 = 'z'
+          end
+          
+          datafield_elem.add_attributes({
+            "tag"=>field.tag,
+            "ind1"=>field.indicator1,
+            "ind2"=>field.indicator2
+          })
+
+          for subfield in field.subfields
+            subfield_element = REXML::Element.new("subfield")
+            
+            # If marc is leniently parsed, we may have some dirty data; using
+            # the blank subfield code should help us locate these later to fix
+            if (subfield.code.match(singleChar) == nil)
+              subfield.code = ' '
+            end
+            
+            subfield_element.add_attribute("code", subfield.code)
+            text = subfield.value
+            subfield_element.add_text(text)
+            datafield_elem.add_element(subfield_element)
+          end
+          
+          e.add_element datafield_elem
+        elsif field.class == MARC::ControlField
+          control_element = REXML::Element.new("controlfield")
+          
+          # We need a marker for invalid tag values (we use 000)
+          unless field.tag.match(ctrlFieldTag)
+            field.tag = "00z"
+          end
+          
+          control_element.add_attribute("tag", field.tag)
+          text = field.value
+          control_element.add_text(text)
+          e.add_element(control_element)
+        end
+      end
+      
+      # return xml
+      return e 
+    end
+  end
+end

data/lib/rwdtinker/rwdcodedir.rb

@@ -0,0 +1,56 @@
+# part of rwdtinker smalllinux@gmail.com
+# copyleft gpl 2008 Steven Gibson
+
+require 'lib/rwdtinker/rwdtinkertools'
+
+tmpmodload = '
+def RwdtinkerTools.findfilesp(d)
+     
+	a = Array.new(Dir[d].entries.sort)
+	#loop through and get the files names
+	a.each do |x|
+		#adjust the filters to the files you want to see...
+		if(!test(?d,x))
+			# only rwd files
+			if x =~ /rb|rwd|txt/
+				fileA=File.open("#{x}","r")        #opens the file thats in fileName as read only
+				@@tempdoc+=fileA.read    #reads the file into the doc string
+				fileA.close    
+			end
+		end
+	end
+	
+end
+
+def RwdtinkerTools.findprogramfiles(codedir, specificdir = "")
+ @@tempdoc = ""
+#get a list of the files and subdirectories on the starting directory only
+  a = Array.new(Dir[codedir].entries.sort)
+  #loop through the list, ignore the files and add all new directories found
+  a.each do |x|
+	  #if a directory...
+	  if(test(?d,x))
+		  # add to the original list of directories
+		  @@root = x + "/**"
+		  #adds the new ones to the array
+		  b = Dir[@@root].entries.sort
+		  b.each do |x|
+			  if(test(?d,x))
+				  a.push(x)  #appends to the end of the array...
+			  end
+		  end
+	  end
+  end
+  a.each do |x|
+	  #if it is a file...
+	  if(!test(?d,x))
+		  a.delete(x)
+	  else              #it is a directory...
+		  findfilesp(x + "/**")
+	  end
+  end
+  return @@tempdoc
+end
+'
+
+RwdtinkerTools.module_eval(tmpmodload)

data/lib/rwdtinker/rwdguidir.rb

@@ -0,0 +1,57 @@
+# part of rwdtinker smalllinux@gmail.com
+# copyleft gpl 2008 Steven Gibson
+
+require 'lib/rwdtinker/rwdtinkertools'
+
+tmpmodload = '
+def RwdtinkerTools.loadguifile(d)
+
+	a = Array.new(Dir[d].entries.sort)
+	#loop through and get the files names
+	a.each do |x|
+		#adjust the filters to the files you want to see...
+		if(!test(?d,x))
+			# only rwd files
+			if x =~ /rb|rwd|txt/
+
+				load x      #opens the file thats in fileName and reads it
+				@@tempdoc += $rwdguivar # adds the file into the doc string
+			end
+		end
+	end
+end 
+
+def RwdtinkerTools.findguifiles(guidir)
+      @@tempdoc = ""
+       #get a list of the files and subdirectories on the starting directory only
+       a = Array.new(Dir[guidir].entries.sort)
+       #loop through the list, ignore the files and add all new directories found
+      a.each do |x|
+	      #if a directory...
+	      if(test(?d,x))
+		     #use this new dir find to add to the original list of directories
+		     @@root = x + "/**"
+		     #adds the new ones to the array
+		     b = Dir[@@root].entries.sort
+		     b.each do |x|
+			       if(test(?d,x))
+				      a.push(x)  #appends to the end of the array...
+			        end
+		       end
+	      end
+       end
+      a.each do |x|
+	      #if it is a file...
+	      if(!test(?d,x)) 
+		    a.delete(x)
+
+	      else #it is a directory...
+		      loadguifile(x + "/**")
+	      end
+      end
+      return @@tempdoc
+      
+end
+'
+
+RwdtinkerTools.module_eval(tmpmodload)