djatoka 0.0.2

data/lib/djatoka/metadata.rb

@@ -0,0 +1,76 @@
+# A class for retrieving metadata on a particular image.
+# See the Djatoka documentation on the {getMetadata service}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2FgetMetadata]
+class Djatoka::Metadata
+  attr_accessor :rft_id, :identifier, :imagefile, :width, :height, :dwt_levels,
+    :levels, :layer_count, :response, :resolver
+  include Djatoka::Net
+
+  def initialize(resolver, rft_id)
+    @resolver = resolver
+    @rft_id = rft_id
+  end
+
+  # To actually retrieve metadata from the server this method must be called.
+  def perform
+    @response = get_json(url)
+    if @response
+      @identifier = response['identifier']
+      @imagefile = response['imagefile']
+      @width = response['width']
+      @height = response['height']
+      @dwt_levels = response['dwtLevels']
+      @levels = response['levels']
+      @layer_count = response['compositingLayerCount']
+    end
+    self
+  end
+
+  # If #perform has been called then this can tell you whether
+  # the status of the request was 'OK' or not (nil).
+  def status
+    if @response
+      'OK'
+    else
+      nil
+    end
+  end
+
+  # Returns an Addressable::URI which can be used to retrieve metadata from the
+  # image server, inspected for query_values, or changed before a request.
+  def uri
+    uri = Addressable::URI.new(resolver.base_uri_params)
+    uri.query_values = {'url_ver'=>'Z39.88-2004','svc_id'=>'info:lanl-repo/svc/getMetadata',
+    'rft_id'=>rft_id }
+    uri
+  end
+
+  # Returns a URL as a String for retrieving metdata from the image server.
+  def url
+    uri.to_s
+  end
+
+  # The Djatoka image server {determines level logic}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_Level_Logic]
+  # different from the number of dwtLevels. This method determines the height and
+  # width of each level. Djatoka only responds with the largest level, so we have
+  # to determine these other levels ourself.
+  def all_levels
+    perform if !response # if we haven't already performed the metadata query do it now
+    levels_hash = Mash.new
+    dwt_levels_i = dwt_levels.to_i
+    (0..dwt_levels_i).each do |level_num|
+      level_height = height.to_i
+      level_width = width.to_i
+
+      times_to_halve = dwt_levels_i - level_num
+      times_to_halve.times do
+        level_height = level_height / 2
+        level_width = level_width / 2
+      end
+
+      levels_hash[level_num] = {:height => level_height, :width => level_width}
+    end
+    levels_hash
+  end
+
+end
+

data/lib/djatoka/net.rb

@@ -0,0 +1,25 @@
+# Module to allow mixing in the ability to retrieve JSON via http.
+# Uses curb if available; otherwise falls back on Net::HTTP
+module Djatoka::Net
+  # Used to get the JSON response from Djatoka for Djatoka::Metadata and ping requests.
+  # Uses curb if the gem is installed; otherwise it falls back on Net::HTTP.
+  def get_json(url)
+    if Djatoka.use_curb?
+      c = Curl::Easy.new(url)
+      data = nil
+      c.on_success{|curl| data = JSON.parse(curl.body_str) }
+      c.perform
+    else
+      uri = URI.parse(url)
+      response = Net::HTTP.get_response(uri)
+      case response
+      when Net::HTTPSuccess
+        data = JSON.parse(response.body)
+      else
+        data = nil
+      end
+    end
+    data
+  end
+end
+

data/lib/djatoka/region.rb

@@ -0,0 +1,134 @@
+# Class to ease the creation of query parameters for retrieval of a region of
+# an image from the Djatoka image server.
+# See the Djatoka documentation on specifics on the {getRegion service}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2FgetRegion]
+#
+# Many of the methods here can be chained together to set query parameters like so:
+#  region = Djatoka::Region.new('http://african.lanl.gov/adore-djatoka/resolver',
+#   'info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3')
+#
+#  region.scale(300).format('image/png').region([1250,550,800,800]).rotate(180).level(5).url
+#    # => "http://african.lanl.gov/adore-djatoka/resolver?svc.level=5&url_ver=Z39.88-2004&svc.region=1250%2C550%2C800%2C800&svc.scale=300&rft_id=info%3Alanl-repo%2Fds%2F5aa182c2-c092-4596-af6e-e95d2e263de3&svc_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajpeg2000&svc_id=info%3Alanl-repo%2Fsvc%2FgetRegion&svc.format=image%2Fpng&svc.rotate=180"
+#
+# All of these values are added in to the query attribute of the Djatoka::Region.
+# Any of the values which are separated by a comma in the {docs}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2FgetRegion]
+# can be sent in as a String or an Array.
+class Djatoka::Region
+  include Djatoka::Common
+  attr_accessor :resolver, :rft_id, :query
+
+  # Pass in a Djatoka::Resolver (or an http URL as a String) and
+  # an rft_id to create a Region. Valid parameters include any of the methods below
+  # which add their value to <tt>query</tt> and return self (so they can be
+  # chained together).
+  def initialize(resolver, rft_id, params={})
+    if resolver.is_a? String
+      @resolver = Djatoka::Resolver.new(resolver)
+    else
+      @resolver = resolver
+    end
+    @rft_id = rft_id
+    @query = Mash.new
+    unless params.empty?
+      map_params(params)
+    end
+  end
+
+  # url for a Region as a String
+  def url
+    uri.to_s
+  end
+
+  # Addressable::URI for the Region
+  def uri
+    uri = Addressable::URI.new(resolver.base_uri_params)
+    uri.query_values = region_params
+    uri
+  end
+
+  # Take the query values and prefixes 'svc.' for the OpenURL.
+  def svc_query
+    prefixed_query = {}
+    query.each do |k,v|
+      prefixed_query['svc.' + k] = v
+    end
+    prefixed_query
+  end
+
+  # Set the scale query parameter as a String or Array. Returns self.
+  def scale(v)
+    if v.is_a? String or v.is_a? Integer or v.is_a? Float
+      query[:scale] = v.to_s
+    elsif v.is_a? Array
+      raise Djatoka::Region::Exception if v.length != 2
+      query[:scale] = v.join(',')
+    end
+    self
+  end
+
+  # Set the level query parameter as a String or Integer. Returns self.
+  def level(v)
+    if v.is_a? String or v.is_a? Integer
+      query[:level] = v.to_s
+    end
+    self
+  end
+
+  # Sets the rotate query parameter as a String or Integer. Returns self.
+  def rotate(v)
+    if v.is_a? String or v.is_a? Integer
+      query[:rotate] = v.to_s
+    end
+    self
+  end
+
+  # Sets the region query parameter as a String or Array. Returns self.
+  # See the {Djatoka documentation}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2FgetRegion]
+  # on the valid values for the region parameter and what they mean.
+  def region(v)
+    if v.is_a? String
+      svc_region = v.split(',')
+      raise Djatoka::Region::Exception if svc_region.length != 4
+      query[:region] = v
+    elsif v.is_a? Array
+      raise Djatoka::Region::Exception if v.length != 4
+      query[:region] = v.join(',')
+    end
+    self
+  end
+
+  # Set the format query parameter for what image format will be returned. Returns self.
+  def format(v)
+    query[:format] = v
+    self
+  end
+
+  def clayer(v)
+    query[:clayer] = v
+    self
+  end
+
+  def region_params
+    region_base_url_params.merge(svc_query)
+  end
+
+  # base parameters for creating a getRegion service OpenURL.
+  def region_base_url_params
+    {'url_ver'=>'Z39.88-2004', 'svc_id'=>'info:lanl-repo/svc/getRegion',
+      'svc_val_fmt'=>'info:ofi/fmt:kev:mtx:jpeg2000',
+      'rft_id' => rft_id
+    }
+  end
+
+  private
+
+  def map_params(params)
+    params.each do |k,v|
+      if k.to_s != 'resolver' and self.respond_to?(k) and
+        self.class.instance_methods(false).include?(k.to_s)
+        self.send(k,v)
+      end
+    end
+  end
+
+end
+

data/lib/djatoka/resolver.rb

@@ -0,0 +1,83 @@
+# A resolver holds the URL for a Djatoka resolver and allows for
+# {ping requests}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2Fping] to the server and shortcuts for the creation of Djatoka::Region
+# and Djatoka::Metadata objects.
+class Djatoka::Resolver
+  include Djatoka::Net
+  attr_accessor :base_url, :host, :path, :port
+
+  def initialize(base_url='http://african.lanl.gov/adore-djatoka/resolver')
+    #if base_url.to_s =~ /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix
+      uri = Addressable::URI.parse(base_url)
+      @base_url = uri.to_s
+      @host = uri.host
+      @path = uri.path
+      @port = uri.port
+    #else #fails this basic validation that it is a URL
+    #  @base_url = nil
+    #  @host = nil
+    #  @path = nil
+    #end
+  end
+
+  # same as #base_url
+  def url
+    base_url
+  end
+
+  # Shortcut to return a Djatoka::Metadata object
+  def metadata(rft_id)
+    Djatoka::Metadata.new(self, rft_id)
+  end
+
+  # Returns a URL as a String for retrieving metadata from the server as JSON.
+  def metadata_url(rft_id)
+    metadata(rft_id).url
+  end
+
+  # Returns a URL as a String which can be used to ping the server.
+  def ping_url(rft_id)
+    ping_url_template.expand(:rft_id => rft_id).to_str
+  end
+
+  # Make a ping request for a particular identifier to the Djatoka server
+  # and get a Mash/Hash in return. See the Djatoka docs on
+  # {the ping service}[http://sourceforge.net/apps/mediawiki/djatoka/index.php?title=Djatoka_OpenURL_Services#info:lanl-repo.2Fsvc.2Fping]
+  def ping(rft_id)
+    m_url = ping_url(rft_id)
+    response = get_json(m_url)
+    if response
+      Mash.new(response)
+    else
+      response
+    end
+  end
+
+  # Shortcut for creating a Djatoka::Region from a Djatoka::Resolver.
+  def region(rft_id, params={})
+    Djatoka::Region.new(self, rft_id, params)
+  end
+
+  # Shortcut for creating an Addressable::URI for a Djatoka::Region.
+  def region_uri(rft_id, params={})
+    Djatoka::Region.new(self, rft_id, params).uri
+  end
+
+  def base_uri_params
+    params = {:host => host, :path => path, :scheme => 'http'}
+    params[:port] = port if port
+    params
+  end
+
+  # same as #base_url
+  def to_s
+    base_url
+  end
+
+  private
+
+  def ping_url_template
+    Addressable::Template.new("#{base_url}?url_ver=Z39.88-2004&svc_id=info:lanl-repo/svc/ping&rft_id={rft_id}")
+  end
+
+end
+

data/lib/djatoka/view_helpers.rb

@@ -0,0 +1,106 @@
+module Djatoka
+
+  # = Djatoka view helpers
+  #
+  # These methods accept an rft_id (identifier) that a Djatoka resolver knows
+  # about and params. Params can include both parameters for a Djatoka query
+  # and params for image_tag. All parameters will be passed on to image_tag allowing
+  # setting of attributes like the <tt>class</tt>.
+  # The resolver can either be set in
+  # config/initializers/djatoka.rb of a Rails application or by setting a
+  # <tt>:resolver</tt> parameter when using one of these helpers.
+  module ViewHelpers
+
+    # Returns an image_tag. Unless params are passed in which constrain the
+    # <tt>scale</tt> or <tt>level</tt> of the image, this will be the highest
+    # resolution of the given image.
+    #   djatoka_image_tag('info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3',
+    #     {:scale => 150, :class => 'djatoka_image'})
+    #
+    #   djatoka_image_tag('info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3',
+    #      {:scale => 150, :region => [1400,500,1400,1500], :class => 'volleyball'})
+    def djatoka_image_tag(rft_id, params={})
+      resolver, region = setup_djatoka_image_tag(rft_id, params)
+      if resolver and region
+        image_tag region.url, params
+      else
+
+      end
+    end
+
+    # Returns an image_tag for a square image. The long side is cropped.
+    # This can be combined with <tt>scale</tt> to determine the dimensions.
+    # The correct level is attempted to be determined by Djatoka::Common#square_params.
+    #   djatoka_square_image_tag('info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3',
+    #      {:scale => 250, :class => 'djatoka_image_larger',
+    #      :resolver => 'http://african.lanl.gov/adore-djatoka/resolver' })
+    def djatoka_square_image_tag(rft_id, params={})
+      resolver, region = setup_djatoka_image_tag(rft_id, params)
+      if resolver and region
+        image_tag(region.square.url, params) #+ debug(region)
+      else
+
+      end
+    end
+
+    # Returns an image tag for an image exactly 75x75
+    #   djatoka_smallbox_image_tag('info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3')
+    def djatoka_smallbox_image_tag(rft_id, params={})
+      resolver, region = setup_djatoka_image_tag(rft_id, params)
+      if resolver and region
+        image_tag region.smallbox.url, params
+      else
+
+      end
+    end
+
+    # Include djatoka_openlayers_script on any page you need pan and zoom to
+    # include the scripts OpenLayers, OpenURL and djatoka. Including those scripts
+    # is required for #djatoka_init_openlayers to work.
+    def djatoka_openlayers_script
+      jquery = '<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>'
+      jquery + javascript_include_tag('OpenLayers','OpenURL', 'djatoka')
+    end
+
+    # View helper to include a bit of jQuery on the page which waits for document
+    # load and then initializes the Ajax, OpenLayers viewer. Since this works
+    # via Ajax, Djatoka will need to be running or proxied at the same domain as
+    # the application to avoid cross-domain restrictions.
+    def djatoka_init_openlayers(rft_id, div_identifier, params={})
+      resolver = determine_resolver(params)
+      metadata_url = resolver.metadata_url(rft_id)
+      %Q|<script type="text/javascript">
+          $(document).ready(function() {openlayersInit('http://#{resolver.host}',
+          '#{metadata_url}',
+          '#{rft_id}', '#{div_identifier}');
+          });
+        </script>
+      |
+    end
+
+    private
+
+    def setup_djatoka_image_tag(rft_id, params)
+      resolver = determine_resolver(params)
+      if resolver
+        region = Djatoka::Region.new(resolver, rft_id, params)
+        return resolver, region
+      else
+      end
+    end
+
+    # Uses the <tt>:resolver</tt> parameter first and then the value stored in
+    # Djatoka.resolver second.
+    def determine_resolver(params)
+      if params[:resolver]
+        Djatoka::Resolver.new(params[:resolver])
+      elsif Djatoka.resolver
+        Djatoka.resolver
+      else
+        nil
+      end
+    end
+
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'djatoka'
+require 'ruby-debug'
+
+class Test::Unit::TestCase
+  def self.with_a_resolver(&block)
+    context 'resolver setup' do
+      setup do
+        @resolver = Djatoka::Resolver.new('http://african.lanl.gov/adore-djatoka/resolver')
+        @identifier = 'info:lanl-repo/ds/5aa182c2-c092-4596-af6e-e95d2e263de3'
+        @url_encoded_identifier = 'info%3Alanl-repo%2Fds%2F5aa182c2-c092-4596-af6e-e95d2e263de3'
+      end
+
+      merge_block(&block) if block_given?
+    end
+  end
+
+end
+