sequencescape-client-api 0.3.5

data/lib/sequencescape-api/capabilities.rb

@@ -0,0 +1,11 @@
+class Sequencescape::Api::Version1
+  def size_in_pages?
+    false
+  end
+end
+
+class Sequencescape::Api::Version2 < Sequencescape::Api::Version1
+  def size_in_pages?
+    true
+  end
+end

data/lib/sequencescape-api/composition.rb

@@ -0,0 +1,37 @@
+module Sequencescape::Api::Composition
+  module Target
+    def self.included(base)
+      base.class_eval do
+        include Sequencescape::Api::Resource::ActiveModel
+        extend Sequencescape::Api::Resource::Attributes
+
+        extend  Sequencescape::Api::Resource::Groups
+        include Sequencescape::Api::Resource::Groups::Json
+      end
+    end
+
+    def initialize(owner, attributes)
+      @owner, @attributes = owner, attributes
+      attributes.each { |k,v| send(:"#{k}=", v) }
+    end
+
+    attr_reader :attributes
+    private :attributes
+  end
+
+  def composed_of(name, options = {})
+    composed_class_name = options[:class_name] || name
+
+    line = __LINE__ + 1
+    class_eval(%Q{
+      def #{name}
+        return nil unless attributes_for?(#{name.to_s.inspect})
+        api.model(#{composed_class_name.inspect}).new(self, attributes_for(#{name.to_s.inspect}))
+      end
+
+      def #{name}=(attributes)
+        @attributes[#{name.to_s.inspect}] = attributes
+      end
+    }, __FILE__, line)
+  end
+end

data/lib/sequencescape-api/connection_factory/actions.rb

@@ -0,0 +1,154 @@
+require 'net/http'
+require 'yajl'
+
+# PINCHED FROM https://gist.github.com/736721
+BEGIN {
+  require 'net/http'
+
+  Net::HTTP.module_eval do
+    alias_method '__initialize__', 'initialize'
+
+    def initialize(*args,&block)
+      __initialize__(*args, &block)
+    ensure
+      @debug_output = $stderr if ENV['HTTP_DEBUG']
+    end
+  end
+}
+
+module Sequencescape::Api::ConnectionFactory::Actions
+  ServerError = Class.new(Sequencescape::Api::ConnectionFactory::ConnectionError)
+
+  def root(handler)
+    read(url, handler)
+  end
+
+  def retrieve(url, handler, content_type)
+    perform(:get, url, nil, content_type) do |response|
+      case response
+      when Net::HTTPSuccess      then response
+      when Net::HTTPUnauthorized then handler.unauthenticated(parse_json_from(response))
+      when Net::HTTPNotFound     then handler.missing(parse_json_from(response))
+      when Net::HTTPRedirection  then handle_redirect(response, handler)
+      else                            raise ServerError, response.body
+      end
+    end
+  end
+
+  def read(url, handler)
+    perform(:get, url) do |response|
+      case response
+      when Net::HTTPSuccess      then handler.success(parse_json_from(response))
+      when Net::HTTPUnauthorized then handler.unauthenticated(parse_json_from(response))
+      when Net::HTTPNotFound     then handler.missing(parse_json_from(response))
+      when Net::HTTPRedirection  then handle_redirect(response, handler)
+      else                            raise ServerError, response.body
+      end
+    end
+  end
+
+  def create(url, body, handler)
+    perform(:post, url, jsonify(body, :action => :create)) do |response|
+      case response
+      when Net::HTTPCreated             then handler.success(parse_json_from(response))
+      when Net::HTTPSuccess             then handler.success(parse_json_from(response)) # TODO: should be error!
+      when Net::HTTPUnauthorized        then handler.unauthenticated(parse_json_from(response))
+      when Net::HTTPUnprocessableEntity then handler.failure(parse_json_from(response))
+      when Net::HTTPNotFound            then handler.missing(parse_json_from(response))
+      when Net::HTTPRedirection         then handle_redirect(response, handler)
+      else                                   raise ServerError, response.body
+      end
+    end
+  end
+
+  def create_from_file(url, file, filename, content_type, handler)
+    perform_for_file(:post, url, file, filename, content_type) do |response|
+      case response
+      when Net::HTTPCreated             then handler.success(parse_json_from(response))
+      when Net::HTTPSuccess             then handler.success(parse_json_from(response)) # TODO: should be error!
+      when Net::HTTPUnauthorized        then handler.unauthenticated(parse_json_from(response))
+      when Net::HTTPUnprocessableEntity then handler.failure(parse_json_from(response))
+      when Net::HTTPNotFound            then handler.missing(parse_json_from(response))
+      when Net::HTTPRedirection         then handle_redirect(response, handler)
+      else                                   raise ServerError, response.body
+      end
+    end
+  end
+
+  def update(url, body, handler)
+    perform(:put, url, jsonify(body, :action => :update)) do |response|
+      case response
+      when Net::HTTPSuccess             then handler.success(parse_json_from(response))
+      when Net::HTTPUnauthorized        then handler.unauthenticated(parse_json_from(response))
+      when Net::HTTPUnprocessableEntity then handler.failure(parse_json_from(response))
+      when Net::HTTPNotFound            then handler.missing(parse_json_from(response))
+      when Net::HTTPRedirection         then handle_redirect(response, handler)
+      else                                   raise ServerError, response.body
+      end
+    end
+  end
+
+  def handle_redirect(response, handler)
+    handler.redirection(parse_json_from(response)) do |read_handler|
+      read(response['Location'], read_handler)
+    end
+  end
+  private :handle_redirect
+
+  def perform(http_verb, url, body = nil, accepts = nil, &block)
+    begin
+      uri = URI.parse(url)
+    rescue URI::InvalidURIError => e
+      raise URI::InvalidURIError, "#{http_verb} failed: #{url.inspect} is not a valid uri"
+    end
+    Net::HTTP.start(uri.host, uri.port) do |connection|
+      connection.read_timeout = read_timeout
+      request_headers =  headers
+      request_headers.merge!('Accept' => accepts) unless accepts.nil?
+      request = Net::HTTP.const_get(http_verb.to_s.classify).new(uri.request_uri, request_headers)
+      unless body.nil?
+        request.content_type = 'application/json'
+        #request.body         = body.to_json
+        request.body         = Yajl::Encoder.encode(body)
+      end
+      yield(connection.request(request))
+    end
+  end
+  private :perform
+
+  def perform_for_file(http_verb, url, file, filename, content_type, &block)
+    uri = URI.parse(url)
+    Net::HTTP.start(uri.host, uri.port) do |connection|
+      connection.read_timeout = read_timeout
+      file_headers = headers.merge!({'Content-Disposition'=> "form-data; filename=\"#{filename}\""})
+      request = Net::HTTP.const_get(http_verb.to_s.classify).new(uri.request_uri, file_headers)
+      request.content_type = content_type
+      #request.body         = body.to_json
+      request.body         = file.read
+      yield(connection.request(request))
+    end
+  end
+  private :perform
+
+  def jsonify(body, options)
+    case
+    when body.nil?        then {}
+    when body.is_a?(Hash) then body
+    else                       body.as_json(options.merge(:root => true))
+    end
+  end
+  private :jsonify
+
+  def parse_json_from(response)
+    raise ServerError, 'server returned non-JSON content' unless response.content_type == 'application/json'
+    Yajl::Parser.parse(StringIO.new(response.body))
+  end
+  private :parse_json_from
+
+  def headers
+    { 'Accept' => 'application/json', 'Cookie' => "WTSISignOn=#{cookie}" }.tap do |standard|
+      standard.merge!('X-Sequencescape-Client-ID' => @authorisation) unless @authorisation.blank?
+    end
+  end
+  private :headers
+end

data/lib/sequencescape-api/connection_factory/helpers.rb

@@ -0,0 +1,9 @@
+module Sequencescape::Api::ConnectionFactory::Helpers
+  def connection_factory=(connection_factory)
+    @connection_factory = connection_factory
+  end
+
+  def connection_factory
+    @connection_factory ||= Sequencescape::Api::ConnectionFactory
+  end
+end

data/lib/sequencescape-api/connection_factory.rb

@@ -0,0 +1,40 @@
+require 'uri'
+
+class Sequencescape::Api::ConnectionFactory
+  ConnectionError = Class.new(::Sequencescape::Api::Error)
+
+  class_attribute :default_url
+
+  def self.create(options)
+    required_options = []
+    required_options.push(:cookie) if options[:authorisation].blank?
+    required_options.push(:url)    if self.default_url.blank?
+
+    required_options.push(:allow_blank => false)
+    options.required!(*required_options) do |missing|
+      raise ::Sequencescape::Api::Error, "No #{missing.or_sentence} set"
+    end
+
+    options[:url] ||= self.default_url
+    new(options)
+  end
+
+  attr_reader :url, :cookie, :read_timeout
+  private :url, :cookie, :read_timeout
+
+  def initialize(options)
+    @url, @cookie, @authorisation = options[:url], options[:cookie], options[:authorisation]
+    @read_timeout = options[:read_timeout] || 120
+  end
+  private_class_method :initialize
+
+  def url_for_uuid(uuid)
+    URI.join(url, uuid).to_s
+  end
+
+  require 'sequencescape-api/connection_factory/helpers'
+  require 'sequencescape-api/connection_factory/actions'
+
+  include Actions
+end
+

data/lib/sequencescape-api/core.rb

@@ -0,0 +1,63 @@
+require 'sequencescape-api/core_ext'
+require 'sequencescape-api/resource_model_proxy'
+require 'sequencescape-api/connection_factory'
+require 'sequencescape-api/capabilities'
+
+require 'active_support'
+require 'active_support/core_ext/class'
+
+class Sequencescape::Api
+  extend Sequencescape::Api::ConnectionFactory::Helpers
+
+  def initialize(options = {})
+    @models, @model_namespace = {}, options.delete(:namespace) || Sequencescape
+    @model_namespace = @model_namespace.constantize if @model_namespace.is_a?(String)
+    @connection = self.class.connection_factory.create(options).tap do |connection|
+      connection.root(self)
+    end
+  end
+
+  attr_reader :capabilities
+  delegate :read, :create, :create_from_file, :update, :retrieve, :to => :@connection
+
+  def read_uuid(uuid, handler)
+    read(@connection.url_for_uuid(uuid), handler)
+  end
+
+  def respond_to?(name, include_private = false)
+    super || @models.keys.include?(name.to_s)
+  end
+
+  def method_missing(name, *args, &block)
+    return super unless @models.keys.include?(name.to_s)
+    ResourceModelProxy.new(self, model(name), @models[name.to_s])
+  end
+  protected :method_missing
+
+  def model(name)
+    parts = name.to_s.split('::').map(&:classify)
+    raise StandardError, "#{name.inspect} is rooted and that is not supported" if parts.first.blank?
+    parts.inject(@model_namespace) { |context, part| context.const_get(part) }
+  rescue NameError => missing_constant_in_user_specified_namespace_fallback
+    raise if @model_namespace == ::Sequencescape
+    parts.inject([ ::Sequencescape, @model_namespace ]) do |(source, dest), part|
+      const_from_source = source.const_get(part)
+      if dest.const_defined?(part)
+        [ const_from_source, dest.const_get(part) ]
+      else
+        [ const_from_source, dest.const_set(part, const_from_source) ]
+      end
+    end.last
+  end
+
+  include BasicErrorHandling
+
+  def success(json)
+    @capabilities = Sequencescape::Api.const_get("Version#{json.delete('revision') || 1}").new
+    @models       = json.each_with_object({}) { |(k, v), models| models[k.to_s.singularize] = v['actions'] }
+  end
+
+  def inspect
+    "#<Sequencescape::Api @connection=#{@connection.inspect}>"
+  end
+end

data/lib/sequencescape-api/core_ext/array.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext/array/conversions'
+
+class Array
+  def or_sentence
+    to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ')
+  end
+end

data/lib/sequencescape-api/core_ext/hash.rb

@@ -0,0 +1,18 @@
+class Hash
+  # Yields all of the missing keys if there are any so that you can do what you like, like
+  # error maybe?
+  def required!(*keys, &block)
+    options = keys.extract_options!
+    return if keys.empty?
+
+    allowance_method = (options[:allow_blank] == false) ? :blank? : :nil?
+
+    missing = keys.inject([]) do |missing, next_key|
+      missing.tap do 
+        value = self[next_key]
+        missing << next_key if value.send(allowance_method)
+      end
+    end
+    yield(missing) unless missing.empty?
+  end
+end

data/lib/sequencescape-api/core_ext.rb

@@ -0,0 +1,2 @@
+require 'sequencescape-api/core_ext/hash'
+require 'sequencescape-api/core_ext/array'

data/lib/sequencescape-api/error_handling.rb

@@ -0,0 +1,42 @@
+require 'active_model/naming'
+require 'active_model/translation'
+
+# Uh, ok, so why do I have to include these if I'm not going to use them!?!!
+require 'active_model/errors'
+
+# Uh, ok, so why do I have to include these when I've kind of said I want everything!?!!
+require 'active_model/validator'
+require 'active_model/validations'
+require 'active_model/callbacks'
+
+module Sequencescape::Api::ErrorHandling
+  def self.included(base)
+    base.class_eval do
+      extend ActiveModel::Translation
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+      include TurnOffValidationOfUuidOnlyRecords
+    end
+  end
+
+  #--
+  # A bit of a fiddle this but any records that are UUID only are typically coming from the user
+  # having selected a load.  If this has happened then there is no data and so none of the
+  # validations should be run.
+  #++
+  module TurnOffValidationOfUuidOnlyRecords
+    def run_validations!
+      uuid_only? ? true : super
+    end
+
+    def uuid_only=(value)
+      @uuid_only = value
+    end
+    private :uuid_only=
+
+    def uuid_only?
+      @uuid_only
+    end
+    private :uuid_only?
+  end
+end

data/lib/sequencescape-api/errors.rb

@@ -0,0 +1,38 @@
+module Sequencescape
+  class Api
+    Error = Class.new(StandardError)
+
+    module GeneralError
+      def initialize(json)
+        super(json['general'])
+      end
+    end
+
+    [ :UnauthenticatedError, :ResourceNotFound ].each do |name|
+      const_set(name, Class.new(Error) { |c| c.send(:include, GeneralError) })
+    end
+
+    class ResourceInvalid < Error
+      def initialize(resource)
+        super('Resource is reported as invalid by the server')
+        @resource = resource
+      end
+
+      attr_reader :resource
+    end
+
+    module BasicErrorHandling
+      def unauthenticated(json)
+        raise Sequencescape::Api::UnauthenticatedError, json
+      end
+
+      def missing(json)
+        raise Sequencescape::Api::ResourceNotFound, json
+      end
+
+      def redirection(json, &block)
+        yield(self)
+      end
+    end
+  end
+end

data/lib/sequencescape-api/finder_methods.rb

@@ -0,0 +1,184 @@
+require 'ostruct'
+
+module Sequencescape::Api::FinderMethods
+  module Delegation
+    def self.included(base)
+      base.with_options(:to => :all) do |all|
+        all.delegate :each, :first, :last, :to_a, :size
+        all.delegate :empty?, :blank?
+        all.delegate :each_page, :first_page, :last_page
+      end
+    end
+  end
+
+  class << self
+    def extended(base)
+      base.singleton_class.send(:include, Delegation)
+    end
+
+    def included(base)
+      base.send(:include, Delegation)
+    end
+  end
+
+  class FindByUuidHandler
+    include Sequencescape::Api::BasicErrorHandling
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def new(*args, &block)
+      # TODO: Consider updating
+      @owner.__send__(:new, *args, &block)
+    end
+    private :new
+
+    def success(json)
+      new(json, true)
+    end
+  end
+
+  def find(uuid)
+    api.read_uuid(uuid, FindByUuidHandler.new(self))
+  end
+
+  class AllHandler
+    include Sequencescape::Api::BasicErrorHandling
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def api(*args, &block)
+      # TODO: Consider updating
+      @owner.__send__(:api, *args, &block)
+    end
+    private :api
+
+    def new(*args, &block)
+      # TODO: Consider updating
+      @owner.__send__(:new, *args, &block)
+    end
+    private :new
+
+    def success(json)
+      ::Sequencescape::Api::PageOfResults.new(api, json, &method(:new))
+    end
+  end
+
+  def all
+    api.read(actions.read, AllHandler.new(self))
+  end
+end
+
+module Sequencescape::Api::FinderMethods::Caching
+  def all(reload = false)
+    @cached_all = super() if @cached_all.nil? or reload
+    @cached_all
+  end
+end
+
+class Sequencescape::Api::PageOfResults
+  include Enumerable
+
+  attr_reader :api, :actions
+  private :api, :actions
+
+  attr_reader :size
+
+  def initialize(api, json, &block)
+    @api, @ctor = api, block
+    update_from_json(json)
+  end
+
+  def empty?
+    return @size.zero? if api.capabilities.size_in_pages?
+
+    first_page
+    @objects.empty?
+  end
+
+  def present?
+    !empty?
+  end
+
+  def each(&block)
+    walk_pages do
+      @objects.each(&block)
+    end
+  end
+
+  def each_page(&block)
+    walk_pages do
+      yield(@objects.dup)
+    end
+  end
+
+  def first
+    first_page
+    @objects.first
+  end
+
+  def last
+    last_page
+    @objects.last
+  end
+
+  def walk_pages
+    first_page
+    while true
+      yield
+      break if actions.next.blank?
+      next_page
+    end
+  end
+  private :walk_pages
+
+  class UpdateHandler
+    include Sequencescape::Api::BasicErrorHandling
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def update_from_json(*args, &block)
+      # TODO: Consider updating
+      @owner.__send__(:update_from_json, *args, &block)
+    end
+    private :update_from_json
+
+    def success(json)
+      update_from_json(json)
+    end
+  end
+
+  [ :first, :last, :previous, :next ].each do |page|
+    line = __LINE__ + 1
+    class_eval(%Q{
+      def #{page}_page
+        self.tap do
+          api.read(actions.#{page}, UpdateHandler.new(self)) unless actions.read == actions.#{page}
+          yield(@objects.dup) if block_given?
+        end
+      end
+    }, __FILE__, line)
+  end
+  private :last_page, :next_page
+
+  def update_from_json(json)
+    json.delete('uuids_to_ids')         # Discard unwanted rubbish
+    actions = json.delete('actions')
+    raise Sequencescape::Api::Error, 'No actions for page!' if actions.blank?
+
+    if api.capabilities.size_in_pages?
+      size = json.delete('size')
+      raise Sequencescape::Api::Error, 'No size for page!' if size.blank?
+      @size = size.to_i
+    end
+
+    raise Sequencescape::Api::Error, 'No object json in page!' if json.keys.empty?
+    @actions, @objects = OpenStruct.new(actions), json[json.keys.first].map(&@ctor)
+  end
+  private :update_from_json
+end