sequencescape-client-api 0.3.5

data/lib/sequencescape-api/associations/base/instance_methods.rb

@@ -0,0 +1,57 @@
+module Sequencescape::Api::Associations::Base::InstanceMethods
+  def self.included(base)
+    base.class_eval do
+      class_attribute :association, :options
+      class_attribute :default_attributes_if_missing, :instance_writer => false
+
+      attr_reader :model
+      delegate :read_timeout, :to => :@owner
+      private :model
+
+      def api(*args, &block)
+        # TODO: Consider updating
+        @owner.__send__(:api, *args, &block)
+      end
+      private :api
+    end
+  end
+
+  def initialize(owner, json = nil)
+    @owner      = owner
+    @attributes = json.nil? ? owner.attributes_for(association, default_attributes_if_missing) : attributes_from(json)
+    @model      = api.model(options[:class_name] || association)
+  end
+
+  def new(*args, &block)
+    model.new(api, *args, &block)
+  end
+  private :new
+
+  # We can be passed several different types of information as though it was JSON:
+  #
+  # 1. It could be a string, in which case we'll assume it's a UUID
+  # 2. It could be an instance of the model we're expected to reference, in which case we take it's attributes
+  # 3. It could be an association like us that references the same model, in which case we take it's attributes
+  # 4. Finally it could actually be the JSON!
+  def attributes_from(json)
+    case
+    when json.is_a?(String)                                 then { uuid: json, uuid_only: true }
+    when json.is_a?(Hash)                                   then json
+    when json.respond_to?(:map)                             then json.map(&method(:attributes_from))
+    when json.is_a?(Sequencescape::Api::Resource)           then json.as_json(:force => true, :action => :update, :root => false, :uuid => true)
+    when json.is_a?(Sequencescape::Api::Associations::Base) then json.as_json(:force => true, :action => :update)
+    else raise json.inspect
+    end
+  end
+  private :attributes_from
+
+  def proxy_present?
+    true
+  end
+end
+
+class NilClass
+  def proxy_present?
+    false
+  end
+end

data/lib/sequencescape-api/associations/base.rb

@@ -0,0 +1,15 @@
+require 'ostruct'
+
+class Sequencescape::Api::Associations::Base
+  require 'sequencescape-api/associations/base/instance_methods'
+
+  include InstanceMethods
+
+  def initialize(owner, json = nil)
+    super
+    @actions = OpenStruct.new(@attributes.delete('actions'))
+  end
+
+  attr_reader :actions
+  private :actions
+end

data/lib/sequencescape-api/associations/belongs_to.rb

@@ -0,0 +1,127 @@
+require 'sequencescape-api/associations/base'
+require 'sequencescape-api/error_handling'
+
+module Sequencescape::Api::Associations::BelongsTo
+  module CommonBehaviour
+    def self.included(base)
+      base.class_eval do
+        include Sequencescape::Api::ErrorHandling
+      end
+    end
+
+    def initialize(*args, &block)
+      super
+      @object = new(@attributes, false)
+    end
+
+    def update_from_json(json)
+      @object.send(:update_from_json, json, false)
+    end
+    private :update_from_json
+
+    def respond_to?(name, include_private = false)
+      # One of our methods, or an eager loaded attribute, or the object needs to be loaded & checked
+      super or is_handled_by_object_instance?(name) or object.respond_to?(name, include_private)
+    end
+
+    def method_missing(name, *args, &block)
+      target = is_handled_by_object_instance?(name) ? @object : object
+      target.send(name, *args, &block)
+    end
+    protected :method_missing
+
+    def is_handled_by_object_instance?(name)
+      return false if @object.nil?
+
+      # TODO: I really hate special cases!
+      case
+      when name.to_sym == :uuid                  then true
+      when @object.eager_loaded_attribute?(name) then true
+      when @object.is_association?(name)         then true
+      else false
+      end
+    end
+    private :is_handled_by_object_instance?
+
+    class LoadHandler
+      include Sequencescape::Api::BasicErrorHandling
+
+      def initialize(owner)
+        @owner = owner
+      end
+
+      delegate :loaded, :to => :@owner
+      private :loaded
+
+      def new(*args, &block)
+        # TODO: Consider updating
+        @owner.__send__(:new, *args, &block)
+      end
+      private :new
+
+      def success(json)
+        new(json, true).tap { loaded = true }
+      end
+    end
+
+    def object
+      @object ||= api.read(actions.read, LoadHandler.new(self))
+      @object
+    end
+    private :object
+
+    def as_json(options = nil)
+      @object.as_json({ :root => false, :uuid => false }.reverse_merge(options || {}))
+    end
+  end
+
+  class InlineAssociationProxy < Sequencescape::Api::Associations::Base
+    include Sequencescape::Api::Associations::BelongsTo::CommonBehaviour
+  end
+
+  class AssociationProxy < Sequencescape::Api::Associations::Base
+    include Sequencescape::Api::Associations::BelongsTo::CommonBehaviour
+
+    self.default_attributes_if_missing = {}
+
+    def initialize(*args, &block)
+      super
+      @loaded = false
+    end
+
+    attr_writer :loaded
+    private :loaded=
+
+    def object
+      @object = nil unless @loaded
+      super
+    end
+    private :object
+
+    def uuid_only?
+      @object.__send__(:uuid_only?)
+    end
+
+    delegate :hash, to: :uuid
+
+    def eql?(other)
+      uuid == other.uuid
+    end
+  end
+
+  def belongs_to(association, options = {}, &block)
+    association = association.to_sym
+
+    proxy = Class.new(
+      case options[:disposition].try(:to_sym)
+      when :inline then InlineAssociationProxy
+      else AssociationProxy
+      end
+    )
+    proxy.association = association
+    proxy.options     = options
+    proxy.instance_eval(&block) if block_given?
+
+    association_methods(association, :belongs_to, proxy)
+  end
+end

data/lib/sequencescape-api/associations/has_many/json.rb

@@ -0,0 +1,10 @@
+module Sequencescape::Api::Associations::HasMany::Json
+  def self.included(base)
+    base.default_attributes_if_missing = []
+  end
+
+  def as_json(options = nil)
+    options = { :root => false, :uuid => true }.reverse_merge(options || {})
+    all.map { |o| o.as_json(options) }.compact
+  end
+end

data/lib/sequencescape-api/associations/has_many/validation.rb

@@ -0,0 +1,37 @@
+module Sequencescape::Api::Associations::HasMany::Validation
+  def run_validations!
+    # NOTE: Don't use all? here because it fails early and we need to see all validation errors
+    all.inject(true) { |state, object| object.run_validations! and state }
+  end
+
+  def errors
+    CompositeErrors.new(self)
+  end
+
+  class CompositeErrors
+    def initialize(association)
+      @association = association
+    end
+
+    def full_messages
+      map_errors(&:full_messages).flatten
+    end
+
+    def empty?
+      map_errors(&:empty?).all?
+    end
+
+    def clear
+      map_errors(&:clear)
+    end
+
+    def [](field)
+      map_errors { |errors| errors[field] }.flatten
+    end
+
+    def map_errors(&block)
+      @association.map(&:errors)
+        .map(&block)
+    end
+  end
+end

data/lib/sequencescape-api/associations/has_many.rb

@@ -0,0 +1,123 @@
+require 'sequencescape-api/finder_methods'
+require 'sequencescape-api/associations/base'
+require 'sequencescape-api/actions'
+
+module Sequencescape::Api::Associations::HasMany
+  require 'sequencescape-api/associations/has_many/json'
+  require 'sequencescape-api/associations/has_many/validation'
+
+  class AssociationProxy < ::Sequencescape::Api::Associations::Base
+    include ::Sequencescape::Api::FinderMethods
+    include ::Sequencescape::Api::FinderMethods::Caching
+    extend  ::Sequencescape::Api::Actions
+    include ::Sequencescape::Api::Associations::HasMany::Json
+    include ::Sequencescape::Api::Associations::HasMany::Validation
+    include Enumerable
+
+    def size
+      return @attributes['size'] if api.capabilities.size_in_pages?
+      all.size
+    end
+
+    def empty?
+      return @attributes['size'].zero? if api.capabilities.size_in_pages?
+      all.empty?
+    end
+
+    def present?
+      !empty?
+    end
+
+    def initialize(owner, json = nil)
+      super
+      @cached_all = case
+        when json.is_a?(Array) then json.map {|js| new_from(js) }
+        else nil
+        end
+    end
+
+    def new_from(json)
+      case
+      when json.is_a?(String) then new(uuid: json) # We've recieved an array of strings, prob. uuids
+      when json.is_a?(Hash) then new(json)
+      else json
+      end
+    end
+
+    def update_from_json(_)
+      @cached_all = nil
+    end
+  end
+
+  class InlineAssociationProxy
+    include Enumerable
+    include ::Sequencescape::Api::FinderMethods::Delegation
+    include ::Sequencescape::Api::Associations::Base::InstanceMethods
+    include ::Sequencescape::Api::Associations::HasMany::Json
+    include ::Sequencescape::Api::Associations::HasMany::Validation
+
+    def initialize(owner, json = nil)
+      super
+      @objects =
+        case
+        when @attributes.is_a?(Array) then @attributes.map(&method(:new))
+        when @attributes.is_a?(Hash)  then @attributes.map { |uuid, json| new(json.merge('uuid' => uuid)) }
+        else raise StandardError, "Cannot handle has_many JSON: #{json.inspect}"
+        end
+    end
+
+    def update_from_json(json)
+      case
+      when json.is_a?(Array) then @objects = json.map(&method(:new))
+      when json.is_a?(Hash)  then update_objects_from_json(json)
+      else raise StandardError, "Cannot handle has_many JSON: #{json.inspect}"
+      end
+    end
+    private :update_from_json
+
+    def update_objects_from_json(json)
+      all.each do |object|
+        object.send(:update_from_json, json[object.uuid]) if json.key?(object.uuid)
+      end
+    end
+    private :update_objects_from_json
+
+    def find(uuid)
+      @objects.detect { |o| o.uuid == uuid }
+    end
+
+    def all
+      @objects
+    end
+
+    def each_page(&block)
+      yield(@objects)
+    end
+
+    def new(json, &block)
+      super(json, false, &block)
+    end
+    private :new
+
+    # We are changed if any of our objects have been changed.
+    def changed?
+      @objects.any?(&:changed?)
+    end
+  end
+
+  def has_many(association, options = {}, &block)
+    association = association.to_sym
+
+    proxy = Class.new(
+      case options[:disposition].try(:to_sym)
+      when :inline then InlineAssociationProxy
+      else AssociationProxy
+      end
+    )
+    proxy.association = association
+    proxy.options     = options
+    proxy.instance_eval(&block) if block_given?
+
+    association_methods(association, :has_many, proxy)
+  end
+end

data/lib/sequencescape-api/associations.rb

@@ -0,0 +1,112 @@
+require 'active_model/errors'
+
+module Sequencescape::Api::Associations
+  def self.extended(base)
+    base.class_eval do
+      include InstanceMethods
+      extend HasMany
+      extend BelongsTo
+    end
+  end
+
+  def association_methods(association, type, proxy)
+    proxy_class_name = [ association, type, 'proxy'].join('_').classify
+    const_set(proxy_class_name.to_sym, proxy)
+
+    line = __LINE__ + 1
+    class_eval(%Q{
+      def #{association}(reload = false)
+        associations[#{association.inspect}]   = nil if !!reload
+        associations[#{association.inspect}] ||= #{proxy_class_name}.new(self)
+        associations[#{association.inspect}]
+      end
+
+      def #{association}=(json)
+        association = associations[#{association.inspect}]
+        if association.proxy_present?
+          association.send(:update_from_json, json)
+        else
+          associations[#{association.inspect}] = #{proxy_class_name}.new(self, json)
+        end
+      end
+      private #{association.inspect}=
+
+      def #{association}?
+        attributes_for?(#{association.inspect})
+      end
+    }, __FILE__, line)
+  end
+  private :association_methods
+
+  module InstanceMethods
+    def initialize(*args, &block)
+      @associations, @errors = {}, nil
+      super
+    end
+
+    attr_reader :associations
+    private :associations
+
+    def is_association?(name)
+      associations.key?(name.to_sym)
+    end
+
+    def attributes_for(path, default_value_if_missing = nil)
+      attributes_from_path(path, default_value_if_missing) or
+        raise Sequencescape::Api::JsonError.new(path.to_s, self)
+    end
+
+    def attributes_for?(path)
+      !!attributes_from_path(path)
+    end
+
+    def attributes_from_path(path, default_value_if_missing = nil)
+      path.to_s.split('.').inject(attributes) { |k,v| k.try(:[], v) } || default_value_if_missing
+    end
+    private :attributes_from_path
+
+    def run_validations!
+      our_result, their_result = super, @associations.values.all?(&:run_validations!)
+      our_result and their_result
+    end
+
+    class CompositeErrors < ::ActiveModel::Errors
+      def [](field)
+        association, *subfield = field.to_s.split('.')
+        errors_from_association = associations[association.to_sym].try(:errors).try(:[], subfield.join('.'))
+        errors_from_association.blank? ? super : errors_from_association
+      end
+
+      def full_messages
+        super.concat(association_errors.map(&:full_messages)).flatten
+      end
+
+      def empty?
+        super and association_errors.all?(&:empty?)
+      end
+
+      def clear
+        association_errors.map(&:clear)
+        super
+      end
+
+      def associations(*args, &block)
+        # TODO: Consider updating
+        @base.__send__(:associations, *args, &block)
+      end
+      private :associations
+
+      def association_errors
+        associations.values.map(&:errors)
+      end
+      private :association_errors
+    end
+
+    def errors
+      @errors ||= CompositeErrors.new(self)
+    end
+  end
+end
+
+require 'sequencescape-api/associations/has_many'
+require 'sequencescape-api/associations/belongs_to'