wax_iiif 0.0.2 → 0.1.0

data/lib/iiif_s3/manifest.rb

@@ -1,151 +0,0 @@
-module IiifS3
-
-  FakeManifest = Struct.new(:id, :type, :label)
-
-  #
-  # Class Manifest is an abstraction over the IIIF Manifest, and by extension over the
-  # entire Presentation API.  It takes the internal representation of data and converts
-  # it into a collection of JSON-LD documents.  Optionally, it also provides the ability
-  # to save these files to disk and upload them to Amazon S3.
-  #
-  # @author David Newbury <david.newbury@gmail.com>
-  #
-
-  class Manifest
-
-    # @return [String] The IIIF default type for a manifest.
-    TYPE = "sc:Manifest"
-
-    include BaseProperties
-
-    #--------------------------------------------------------------------------
-    # CONSTRUCTOR
-    #--------------------------------------------------------------------------
-
-    # This will initialize a new manifest.
-    #
-    # @param [Array<ImageRecord>] image_records An array of ImageRecord types
-    # @param [<type>] config <description>
-    # @param [<type>] opts <description>
-    # 
-    def initialize(image_records,config, opts = {})
-      @config = config
-      image_records.each do |record|
-        raise IiifS3::Error::InvalidImageData, "The data provided to the manifest were not ImageRecords" unless record.is_a? ImageRecord
-      end
-
-      @primary = image_records.find{|obj| obj.is_primary}
-      raise IiifS3::Error::InvalidImageData, "No 'is_primary' was found in the image data." unless @primary
-      raise IiifS3::Error::MultiplePrimaryImages, "Multiple primary images were found in the image data." unless image_records.count{|obj| obj.is_primary} == 1
-
-      self.id =          "#{@primary.id}/manifest"
-      self.label =        @primary.label       || opts[:label]                 || ""
-      self.description =  @primary.description || opts[:description]
-      self.attribution =  @primary.attribution || opts.fetch(:attribution, nil) 
-      self.logo =         @primary.logo        || opts.fetch(:logo, nil)
-      self.license =      @primary.license     || opts.fetch(:license, nil)
-      self.metadata =     @primary.metadata    || opts.fetch(:metadata, nil)
-
-      @sequences = build_sequence(image_records)
-    end
-
-    #
-    # @return [String]  the JSON-LD representation of the manifest as a string.
-    # 
-    def to_json
-      obj = base_properties
-
-      obj["thumbnail"]   = @primary.variants["thumbnail"].uri
-      obj["viewingDirection"] = @primary.viewing_direction 
-      obj["viewingHint"] = @primary.is_document ? "paged" : "individuals"
-      obj["sequences"] = [@sequences]
-
-      return JSON.pretty_generate obj
-    end
-
-    #
-    # Save the manifest and all sub-resources to disk, using the
-    # paths contained withing the IiifS3::Config object passed at 
-    # initialization.
-    # 
-    # Will create the manifest, sequences, canvases, and annotation subobjects.
-    #
-    # @return [Void] 
-    # 
-    def save_all_files_to_disk
-      data = JSON.parse(self.to_json)
-      save_to_disk(data)
-      data["sequences"].each do |sequence|
-        save_to_disk(sequence)
-        sequence["canvases"].each do |canvas|
-          save_to_disk(canvas)
-          canvas["images"].each do |annotation|
-            save_to_disk(annotation)
-          end
-        end
-      end
-      return nil
-    end
-
-    protected
-
-
-    #--------------------------------------------------------------------------
-    def build_sequence(image_records,opts = {name: DEFAULT_SEQUENCE_NAME}) 
-      name = opts.delete(:name)
-      seq_id = generate_id "#{@primary.id}/sequence/#{name}"
-
-      opts.merge({
-        "@id" => seq_id,
-        "@type" => SEQUENCE_TYPE,
-        "canvases" => image_records.collect {|image_record| build_canvas(image_record)}
-      })
-    end
-
-    #--------------------------------------------------------------------------
-    def build_canvas(data)
-
-      canvas_id = generate_id "#{data.id}/canvas/#{data.section}"
-
-      obj = {
-        "@type" => CANVAS_TYPE,
-        "@id"   => canvas_id,
-        "label" => data.section_label,
-        "width" => data.variants["full"].width.floor,
-        "height" => data.variants["full"].height.floor,
-        "thumbnail" => data.variants["thumbnail"].uri
-      }
-      obj["images"] = [build_image(data, obj)]
-
-      # handle objects that are less than 1200px on a side by doubling canvas size
-      if obj["width"] < MIN_CANVAS_SIZE || obj["height"] < MIN_CANVAS_SIZE
-        obj["width"]  *= 2
-        obj["height"] *= 2
-      end
-      return obj
-    end
-
-    #--------------------------------------------------------------------------
-    def build_image(data, canvas)     
-      annotation_id =  generate_id "#{data.id}/annotation/#{data.section}"
-      {
-        "@type" => ANNOTATION_TYPE,
-        "@id"   => annotation_id,
-        "motivation" => MOTIVATION,
-        "resource" => {
-          "@id" => data.variants["full"].uri,
-          "@type" => IMAGE_TYPE,
-          "format" => data.variants["full"].mime_type || "image/jpeg",
-          "service" => {
-            "@context" => IiifS3::IMAGE_CONTEXT,
-            "@id" => data.variants["full"].id,
-            "profile" => IiifS3::LEVEL_0,
-          },
-          "width" => data.variants["full"].width,
-          "height" => data.variants["full"].height,
-        },
-        "on" => canvas["@id"]
-      }
-    end   
-  end
-end

data/lib/iiif_s3/version.rb

@@ -1,5 +0,0 @@
-module IiifS3
-  #
-  # @return [String] The current library version
-  VERSION = "0.1.0"
-end

data/spec/iiif_s3/builder_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-require 'fileutils'
-
-describe IiifS3::Builder do
-  # before(:each) do
-  #   fake_aws_bucket = OpenStruct.new({
-  #     "exists?" => "true"
-  #   })
-  #   unless ENV["TEST_INTERNET_CONNECTIVITY"]
-  #     allow(Aws::S3::Bucket).to receive(:new) {nil}
-  #     allow(Aws::S3::Bucket).to receive(:exists?) {true}
-  #   end
-  # end
-
-  let (:iiif) { IiifS3::Builder.new() }
-  let (:test_object_0) {ImageRecord.new({"id" => 1, "page_number" => 1})}
-  let (:test_object_1) {ImageRecord.new({"id" => 2, "page_number" => 1})}
-  let (:test_object_2) {ImageRecord.new({"id" => 2, "page_number" => 2})}
-  let (:data) {[test_object_0, test_object_1,test_object_2]}
-
-  context "When initializing" do
-    it "generates manifests" do
-      expect(iiif.manifests).to eq(Array.new)
-    end
-    it "uses the default config" do
-      expect(iiif.config).to eq(IiifS3::Config.new)
-    end
-    it "will accept a configuration hash" do
-      opts = {tile_width: 99}
-      iiif2 = IiifS3::Builder.new(opts)
-      expect(iiif2.config.tile_width).to eq(99)
-    end
-  end
-
-  context "loading data" do
-    it "will accept an array of objects" do
-      iiif.load(data)
-      expect(iiif.data).to eq(data)
-    end 
-    it "will accept a single object" do 
-      iiif.load(test_object_1)
-      expect(iiif.data).to eq([test_object_1])
-    end
-
-    it "will error if the data is bad" do
-      expect{iiif.load({random: "hash"})}.to raise_error(IiifS3::Error::InvalidImageData)
-      expect{iiif.load([{random: "hash"}])}.to raise_error(IiifS3::Error::InvalidImageData)
-    end
-  end
-
-  context "when processing data" do
-    include_context("fake variants")
-    include_context("fake data")
-
-    before(:example) do
-      @iiif = IiifS3::Builder.new({base_url: 'http://0.0.0.0', verbose: true, thumbnail_size: 120})
-      @iiif.load(@fake_data)
-      allow(@iiif).to receive(:generate_tiles) {nil}
-      allow(@iiif).to receive(:generate_variants) {@fake_variants}
-
-    end
-    it "does not fail with no data" do
-      expect {iiif.process_data}.not_to raise_error
-    end
-
-    it "does not fail with real data" do
-      expect {@iiif.process_data}.not_to raise_error
-    end
-  
-    it " passes the Temporary Manifest Check" do
-      @iiif.process_data
-      expect(@iiif.manifests.count).to eq 1
-      expect(@iiif.manifests.first.to_json).to eq @fake_manifest
-    end
-  end
-
-
-  context "when dealing with already loaded data" do
-    include_context("fake data")
-    include_context("fake variants")
-
-    before(:example) do
-      @dir = Dir.mktmpdir
-      @iiif = IiifS3::Builder.new({output_dir: @dir, base_url: 'http://0.0.0.0', verbose: true, thumbnail_size: 120})
-      @iiif.load(@fake_data)
-      @info_json = "#{@dir}/images/1-1/info.json"
-      allow(@iiif).to receive(:generate_tiles) {nil}
-      allow(@iiif).to receive(:generate_variants) {@fake_variants}
-      @iiif.process_data
-    end
-
-    after(:example) do
-      FileUtils.remove_entry @dir
-    end
-
-    it "has the temporary file" do
-      expect(File.exist?(@info_json)).to eq true
-    end
-
-   it "does try to generate images if that file is missing" do
-      File.delete(@info_json)
-      @iiif.process_data
-      expect(@iiif).to have_received(:generate_tiles).twice
-      expect(@iiif).to have_received(:generate_variants).twice
-    end
-
-    it "does not try to generate images if that file is present" do
-      @iiif.process_data
-      expect(@iiif).to have_received(:generate_tiles).once
-      expect(@iiif).to have_received(:generate_variants).once
-    end
-
-    it "generates the correct manifest anyway" do
-      @iiif.process_data
-      expect(@iiif.manifests.count).to eq 1
-      expect(@iiif.manifests.first.to_json).to eq @fake_manifest
-    end
-
-  end
-
-  context "When load_csving CSV files" do
-    it "accepts a path" do
-      expect{iiif.load_csv('./spec/data/test.csv')}.not_to raise_error()
-    end
-    it "fails on blank CSV files" do
-      expect{iiif.load_csv('./spec/data/blank.csv')}.to raise_error(IiifS3::Error::BlankCSV)
-    end
-    it "fails on invalid CSV files" do
-      expect{iiif.load_csv('./spec/data/invalid.csv')}.to raise_error(IiifS3::Error::InvalidCSV)
-    end
-    it "fails on missing CSV files" do
-      expect{iiif.load_csv('./spec/data/i_dont_exist.csv')}.to raise_error(IiifS3::Error::InvalidCSV)
-    end
-  end
-
-  context "When loading a CSV file" do
-    it "saves the data into the @data param" do
-      expect(iiif.data).to be_nil
-      iiif.load_csv('./spec/data/test.csv')
-      expect(iiif.data).not_to be_nil
-    end
-    it "removes headers" do
-      iiif.load_csv('./spec/data/test.csv')
-      expect(iiif.data[0]['image_path']).to eq('spec/data/test.jpg')        
-    end
-    it "doesn't remove headers if not present" do
-      iiif.load_csv('./spec/data/no_header.csv')
-      expect(iiif.data[0]['image_path']).to eq('spec/data/test.jpg')        
-    end
-  end
-end

data/spec/iiif_s3/collection_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require "base_properties_spec"
-
-describe IiifS3::Collection do
-  let (:config) {IiifS3::Config.new()}
-  context "base" do
-      before(:each) do
-        @object = IiifS3::Collection.new("Test data", config)
-      end
-      it_behaves_like "base properties"
-  end
-
-  context "initialization" do
-    it "initializes without issues" do
-      collection = nil
-      expect{collection = IiifS3::Collection.new("Test data", config)}.not_to raise_error
-      expect(collection.id).to eq("http://0.0.0.0/collection/top.json")
-    end
-    it "initializes without issues when provided a name" do
-      collection = nil
-      expect{collection = IiifS3::Collection.new("Test data", config, "name")}.not_to raise_error
-      expect(collection.id).to eq("http://0.0.0.0/collection/name.json")
-    end
-    it "initializes without issues when provided a name with a space in it" do
-      collection = nil
-      expect{collection = IiifS3::Collection.new("Test data", config, "name and space")}.not_to raise_error
-      expect(collection.id).to eq("http://0.0.0.0/collection/name%20and%20space.json")
-    end
-    it "fails if there is no label" do
-      expect{collection = IiifS3::Collection.new(nil, config)}.to raise_error(IiifS3::Error::MissingCollectionName)
-    end
-    it "fails if there is a blank label" do
-      expect{collection = IiifS3::Collection.new("", config)}.to raise_error(IiifS3::Error::MissingCollectionName)
-    end
-    it "has the correct default name" do
-      collection = IiifS3::Collection.new("Test data", config)
-      expect(collection.id).to include "top.json"
-    end
-  end
-  context "data init" do
-    include_context("fake data")
-    let(:collection) {IiifS3::Collection.new("Test Data", config, "name")}
-    let(:manifest) {IiifS3::Manifest.new([@fake_data],config)}
-    it "has a label" do
-      expect(collection.label).to eq "Test Data"
-    end
-    it "has an id" do
-      expect(collection.id).to eq "http://0.0.0.0/collection/name.json"
-    end
-   
-    it "allows you to add a collection" do
-      newCollection = collection.clone
-      expect{collection.add_collection(newCollection)}.not_to raise_error
-    end
-
-    it "fails if you add something else to a collection" do
-      newCollection = {}
-      expect{collection.add_collection(newCollection)}.to raise_error(IiifS3::Error::NotACollection)
-    end
-
-
-    it "generates correct JSON" do
-      collection.add_manifest(manifest)
-      expect(collection.to_json).to eq @fake_collection
-    end
-
-  end
-end

data/spec/iiif_s3/config_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-
-describe IiifS3::Config do
-  context "comparing" do
-    it "shows equal things to be equal" do
-      expect(IiifS3::Config.new).to eq(IiifS3::Config.new)
-    end
-    it "shows different things to be different" do
-      opts = {tile_width: 99, upload_to_s3: false}
-      opts2 = {tile_width: 100, upload_to_s3: false}
-      expect(IiifS3::Config.new opts).not_to eq(IiifS3::Config.new opts2)      
-    end
-  end
-end

data/spec/iiif_s3/image_info_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-include IiifS3
-
-describe IiifS3::ImageInfo do
-
-  let(:uri) {"http://www.example.com/test/1"}
-  include_context("fake variants")
-
-  context "intialization" do
-
-  
-    it "initializes without errors" do  
-      expect{ImageInfo.new(uri,@fake_variants)}.not_to raise_error
-    end
-    it "raises an error without a 'full' variant" do
-      @fake_variants.delete "full"
-      expect{ImageInfo.new(uri,@fake_variants)}.to raise_error(Error::InvalidImageData)
-    end
-    it "raises an error without a 'thumbnail' variant" do
-      @fake_variants.delete "thumbnail"
-      expect{ImageInfo.new(uri,@fake_variants)}.to raise_error(Error::InvalidImageData)
-    end
-  end
-
-
-  context "valid data" do
-    before(:example) do 
-      @info = ImageInfo.new(uri,@fake_variants)
-    end  
-
-    it "generates correct sizes" do
-      expect(@info.sizes).to eq([{"width" => 1000, "height" => 1200},{"width" => 100, "height" => 120}])
-    end
-
-    it "generates nil when no tile data appears" do
-      expect(@info.tiles).to be_nil
-    end
-
-    it "generates tile info when tile data appears" do
-      info = ImageInfo.new(uri,@fake_variants,500,[1,2,4])
-      expect(info.tiles).to eq([{"width" => 500, "scaleFactors" => [1,2,4]}])
-    end
-
-    it "has the correct other methods" do
-      expect(@info).to respond_to "context"
-      expect(@info).to respond_to "protocol"
-      expect(@info).to respond_to "profile"
-      expect(@info).to respond_to "service"
-    end
-
-    it "generates correct JSON" do
-      expect(@info.to_json).to eq(@fake_image_info)
-    end
-  end
-end