cul-fedora-arm 0.5.1

data/.buildpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<buildpath>
+	<buildpathentry kind="src" path="lib"/>
+	<buildpathentry kind="src" path="test"/>
+	<buildpathentry exported="true" kind="con" path="org.eclipse.dltk.launching.INTERPRETER_CONTAINER"/>
+</buildpath>

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+private
+.DS_Store
+coverage
+rdoc
+pkg

data/.loadpath

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<loadpath>
+	<pathentry path="" type="src"/>
+	<pathentry exported="true" path="org.rubypeople.rdt.launching.RUBY_CONTAINER" type="con"/>
+</loadpath>

data/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>cul-fedora-arm</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.dltk.core.scriptbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.dltk.ruby.core.nature</nature>
+	</natures>
+</projectDescription>

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 James Stuart
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,29 @@
+= cul-fedora-arm
+
+This is designed, given an input specification referring to several metadata and resource files, create and ingest objects into a Fedora reposito
+
+== Input 
+
+The input consists of a specification of relationships and metadata that can be given in one of three ways:
+* A file name
+* An enumerable array of strings
+* A series of FILL IN objects
+
+=== Input Specification
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 James Stuart. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cul-fedora-arm"
+    gem.summary = %Q{Tools for dealing with Cul ARM specification}
+    gem.description = %Q{Tools for dealing with Cul ARM specification}
+    gem.email = "tastyhat@jamesstuart.org"
+    gem.homepage = "http://github.com/tastyhat/cul-fedora-arm"
+    gem.authors = ["James Stuart"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    gem.add_development_dependency "thoughtbot-factory_girl"
+    gem.add_dependency "activesupport"
+    gem.add_dependency "ruby-fedora"
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cul-fedora-arm #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/cul-fedora-arm.gemspec

@@ -0,0 +1,92 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cul-fedora-arm}
+  s.version = "0.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["James Stuart"]
+  s.date = %q{2009-10-21}
+  s.description = %q{Tools for dealing with Cul ARM specification}
+  s.email = %q{tastyhat@jamesstuart.org}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".buildpath",
+     ".document",
+     ".gitignore",
+     ".loadpath",
+     ".project",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "cul-fedora-arm.gemspec",
+     "lib/cul-fedora-arm.rb",
+     "lib/cul/fedora/.rb",
+     "lib/cul/fedora/arm/builder.rb",
+     "lib/cul/fedora/arm/foxml_builder.rb",
+     "lib/cul/fedora/arm/tasks.rb",
+     "lib/cul/fedora/connector.rb",
+     "lib/cul/fedora/image/image.rb",
+     "test/cul_fedora_arm_builder_test.rb",
+     "test/cul_fedora_arm_tasks_test.rb",
+     "test/cul_fedora_image_test.rb",
+     "test/factories.rb",
+     "test/fixtures/case1/builder-template-noheader.txt",
+     "test/fixtures/case1/builder-template.txt",
+     "test/fixtures/case2/builder-template.txt",
+     "test/fixtures/case3/builder-template.txt",
+     "test/fixtures/case3/test001.bmp",
+     "test/fixtures/case3/test001.gif",
+     "test/fixtures/case3/test001.jpg",
+     "test/fixtures/case3/test001.png",
+     "test/fixtures/case3/test001.tiff",
+     "test/fixtures/case4/builder-template.txt",
+     "test/fixtures/case4/test-mods.xml",
+     "test/helpers/soap_inputs.rb",
+     "test/helpers/template_builder.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/tastyhat/cul-fedora-arm}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Tools for dealing with Cul ARM specification}
+  s.test_files = [
+    "test/cul_fedora_arm_builder_test.rb",
+     "test/cul_fedora_arm_tasks_test.rb",
+     "test/cul_fedora_image_test.rb",
+     "test/factories.rb",
+     "test/helpers/soap_inputs.rb",
+     "test/helpers/template_builder.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_development_dependency(%q<thoughtbot-factory_girl>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_runtime_dependency(%q<ruby-fedora>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<thoughtbot-factory_girl>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<ruby-fedora>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<thoughtbot-factory_girl>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<ruby-fedora>, [">= 0"])
+  end
+end

data/lib/cul-fedora-arm.rb

@@ -0,0 +1,6 @@
+require "cul/fedora/arm/foxml_builder"
+require "cul/fedora/arm/builder"
+require "cul/fedora/arm/tasks"
+require "cul/fedora/connector"
+require "activesupport"
+require "ruby-fedora"

data/lib/cul/fedora/arm/builder.rb

@@ -0,0 +1,230 @@
+
+module Cul
+  module Fedora
+    module Arm
+
+      # This class is for building ARM resource models in Fedora
+      #
+      # Authors::  James Stuart (mailto:james.stuart at columbia.edu), Benjamin Armintor (mailto: ba2213 at columbia.edu)
+      # License::
+      # Dependencies:: activesupport 
+      
+      class Builder
+
+        # TODO: abstract this to allow for multiple patterns
+        
+        # list of columns for a template with no header row
+        DEFAULT_TEMPLATE_HEADER = [:sequence, :target, :model_type, :source, :template_type, :dc_format, :id, :pid, :action, :license]
+        
+        # columns that must have values
+        REQUIRED_COLUMNS = [:sequence]
+        
+        # columns that must be included in a template
+        MANDATORY_COLUMNS = [:sequence, :target, :model_type]
+        
+        # list of columns which may have values
+        VALID_COLUMNS = [:sequence, :target, :model_type, :source, :template_type, :dc_format, :id, :pid, :action, :license]
+
+        FOXML_BUILDER = FoxmlBuilder.new()
+        # array of individual hash: each hash corresponds to a metadata or resource.
+        
+        attr_reader :parts, :connector
+        
+
+        # creates a Builder object. Can be used with no arguments, or with ONE of the following options
+        # [:template]:: builds parts based on an enumerable list of strings (for example, the result of File.open) 
+        # [:header]:: designates for a template whether a header is specified
+        # and one or more of the following:
+        # [:host]:: designates a fedora host server name
+        # [:admin_port]:: designates a fedora host port for admin
+        # [:admin_ssl]:: designates whether ssl should be used
+        
+        # [:user]:: designates a fedora user
+        # [:pwd]:: designates a fedora user credential
+        def initialize(*args)
+          options = args.extract_options!
+
+          @parts = []
+          @connector = options.delete(:connector)
+          @namespace = options.delete(:ns)
+          
+          if (template = options.delete(:template)) || (file = options.delete(:file))
+            template ||= File.open(file,"r")
+
+            header = options.delete(:header) 
+            header = true if header.nil?
+
+            raise ArgumentError, "arguments should only include one of the following: :template, :file" unless options.empty?
+            
+            parse_template(template, header)
+          else
+            
+            raise ArgumentError, "arguments should only include one of the following: :template, :file" unless options.empty?
+          end
+          
+        end
+
+        # adds one part to the parts array
+        # arguments are a hash array of column name (underscored symbols) to values
+        def add_part(*args)
+          value_hash = args.extract_options!
+          
+          test_for_invalid_columns(value_hash.keys)
+          test_for_required_columns(value_hash)
+          
+          raise "Sequence ID already taken" if part_by_sequence(value_hash[:sequence])
+          
+          @parts << value_hash
+        end
+
+        # looks for a part by :sequence key
+        # note: if loading from a template, sequence will not be an integer, but rather a string
+        def part_by_sequence(sequence_id)
+          @parts.detect { |p| p[:sequence] == sequence_id}
+        end
+        # looks for a part by :pid key
+        def part_by_pid(pid)
+          @parts.detect { |p| p[:pid] == pid}
+        end
+        
+        def purge(pid)
+          if(@apim)
+            purge = Tasks::PurgeTask.new(pid)
+            purge.post(@connector)
+          end
+        end
+        
+        def process_parts()
+          reserve_pids(parts)
+          parts.each { |part_hash|
+            process(part_hash)
+          }
+        end
+        
+        def process(value_hash)
+          # part is a hash
+          op = value_hash[:action] + "_" + value_hash[:model_type]
+          op.downcase!
+          op = op.intern
+          raise "Unknown operation #{op}" unless method(op)
+          return method(op).call(value_hash) 
+        end
+        
+        def insert_aggregator(value_hash)
+          data = FOXML_BUILDER.build(value_hash)
+          task = Tasks::InsertFoxmlTask.new(data)
+          task.post(@connector)
+          task.response
+        end
+        def insert_metadata(value_hash)
+          data = FOXML_BUILDER.build(value_hash)
+          task = Tasks::InsertFoxmlTask.new(data)
+          task.post(@connector)
+          task.response
+        end
+        def insert_resource(value_hash)
+          data = FOXML_BUILDER.build(value_hash)
+          task = Tasks::InsertFoxmlTask.new(data)
+          task.post(@connector)
+          task.response
+        end
+       
+        def reserve_pids(parts=@parts)
+          assigned = []
+          if (parts.nil?)
+            return assigned
+          end
+          missing = 0
+          # count missing pids
+          parts.each { |part|
+            test_for_required_columns(part)
+            if ( part[:action].strip().eql?('insert'))
+              if ( !part.has_key?(:pid) or part[:pid].strip().empty?)
+                missing += 1
+              end
+            end
+          }
+          task = Tasks::ReservePidsTask.new(missing,@namespace)
+          task.post(@connector)
+          pids = (missing == 1)? [task.response.pid]:task.response.pid
+          # assign new pids
+          parts.each { |part|
+            if ( part[:action].strip().eql?('insert'))
+              if ( !part.has_key?(:pid) or part[:pid].strip().empty?)
+                part[:pid] = pids.delete_at(0)
+                assigned.push(part[:pid])
+              end
+            end
+          }
+          # make substitutions in target values
+          parts.each { |part|
+            if(part.has_key?(:target))
+              target = part[:target]
+              targets = target.split(';')
+              targets.collect! { |t|
+                if (t =~ /^\d+$/)
+                  t = part_by_sequence(t)[:pid]
+                end
+                t
+              }
+              part[:target] = targets.join(';')
+            end
+          }
+          assigned
+        end
+
+
+
+        protected
+        
+
+        # checks keys of a hash to make sure all elements of REQUIRED_COLUMNS are contained. 
+        def test_for_required_columns(value_hash)
+          missing_values = REQUIRED_COLUMNS.select { |col| !value_hash.has_key?(col) || value_hash[col].nil? }
+          if (value_hash.has_key?(:action) and value_hash[:action].eql?('update'))
+            raise "Update operations require a PID" unless (value_hash.has_key(:pid) and !value_hash[:pid].strip().eql?(''))
+          end
+          raise "Missing required values #{missing_values.join(",")}" unless missing_values.empty?
+        end
+        
+        # checks list of column names to make sure every one is in VALID_COLUMNS 
+        def test_for_invalid_columns(columns)
+          invalid_columns = columns.select { |c| !VALID_COLUMNS.include?(c) }
+          raise "Invalid column(s) found: #{invalid_columns.join(",")}" unless invalid_columns.empty?          
+        end
+        
+        # parses an enumerable of strings to build parts
+        # an optional header row specifies the columns, however sequence must be included and must be first
+        # TODO: fix this to include a header option
+        def parse_template(template, has_header_row)
+          header_columns = DEFAULT_TEMPLATE_HEADER     # list of columns
+          
+          
+          template.each_with_index do |line, i|
+          
+            # if first row, check for header
+            if i == 0
+              header_columns = line.split("\t").collect { |cn| cn.strip.underscore.to_sym } if has_header_row
+              
+              # check to make sure all mandatory columns are in the template
+              missing_mandatory_columns = MANDATORY_COLUMNS.select { |c| !header_columns.include?(c) }
+              raise "Missing mandatory column(s) found: #{missing_mandatory_columns.join(",")}" unless missing_mandatory_columns.empty?
+
+              test_for_invalid_columns(header_columns)
+
+              # skip header_row
+              next if has_header_row
+
+            end
+            
+            # create hash out of columns and whitespace-stripped values
+            value_hash = Hash[*header_columns.zip(line.split("\t").collect(&:strip)).flatten]
+            add_part(value_hash)
+          end
+          parts
+        end
+      end
+    end
+  end
+
+end