sequencescape-client-api 0.3.6 → 0.4.0.pre.rc1

data/lib/sequencescape-api/associations.rb

@@ -9,12 +9,12 @@ module Sequencescape::Api::Associations
     end
   end
 
-  def association_methods(association, type, proxy)
-    proxy_class_name = [ association, type, 'proxy'].join('_').classify
+  def association_methods(association, type, proxy) # rubocop:todo Metrics/MethodLength
+    proxy_class_name = [association, type, 'proxy'].join('_').classify
     const_set(proxy_class_name.to_sym, proxy)
 
     line = __LINE__ + 1
-    class_eval(%Q{
+    class_eval(%{
       def #{association}(reload = false)
         associations[#{association.inspect}]   = nil if !!reload
         associations[#{association.inspect}] ||= #{proxy_class_name}.new(self)
@@ -40,7 +40,8 @@ module Sequencescape::Api::Associations
 
   module InstanceMethods
     def initialize(*args, &block)
-      @associations, @errors = {}, nil
+      @associations = {}
+      @errors = nil
       super
     end
 
@@ -61,12 +62,13 @@ module Sequencescape::Api::Associations
     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
+      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 = super
+      their_result = @associations.values.all?(&:run_validations!)
       our_result and their_result
     end
 

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

@@ -7,7 +7,7 @@ class Sequencescape::Api::Associations::Base
 
   def initialize(owner, json = nil)
     super
-    @actions = OpenStruct.new(@attributes.delete('actions'))
+    @actions = OpenStruct.new(@_attributes_.delete('actions'))
   end
 
   attr_reader :actions

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

@@ -1,11 +1,12 @@
 module Sequencescape::Api::Associations::Base::InstanceMethods
-  def self.included(base)
+  def self.included(base) # rubocop:todo Metrics/MethodLength
     base.class_eval do
       class_attribute :association, :options
-      class_attribute :default_attributes_if_missing, :instance_writer => false
+      class_attribute :default_attributes_if_missing, instance_writer: false
 
       attr_reader :model
-      delegate :read_timeout, :to => :@owner
+
+      delegate :read_timeout, to: :@owner
       private :model
 
       def api(*args, &block)
@@ -17,9 +18,9 @@ module Sequencescape::Api::Associations::Base::InstanceMethods
   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)
+    @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)
@@ -38,8 +39,9 @@ module Sequencescape::Api::Associations::Base::InstanceMethods
     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)
+    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

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

@@ -11,7 +11,7 @@ module Sequencescape::Api::Associations::BelongsTo
 
     def initialize(*args, &block)
       super
-      @object = new(@attributes, false)
+      @object = new(@_attributes_, false)
     end
 
     def update_from_json(json)
@@ -50,7 +50,7 @@ module Sequencescape::Api::Associations::BelongsTo
         @owner = owner
       end
 
-      delegate :loaded, :to => :@owner
+      delegate :loaded, to: :@owner
       private :loaded
 
       def new(*args, &block)
@@ -71,7 +71,7 @@ module Sequencescape::Api::Associations::BelongsTo
     private :object
 
     def as_json(options = nil)
-      @object.as_json({ :root => false, :uuid => false }.reverse_merge(options || {}))
+      @object.as_json({ root: false, uuid: false }.reverse_merge(options || {}))
     end
   end
 
@@ -109,7 +109,7 @@ module Sequencescape::Api::Associations::BelongsTo
     end
   end
 
-  def belongs_to(association, options = {}, &block)
+  def belongs_to(association, options = {}, &block) # rubocop:todo Metrics/MethodLength
     association = association.to_sym
 
     proxy = Class.new(

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

@@ -15,12 +15,14 @@ module Sequencescape::Api::Associations::HasMany
     include Enumerable
 
     def size
-      return @attributes['size'] if api.capabilities.size_in_pages?
+      return @_attributes_['size'] if api.capabilities.size_in_pages?
+
       all.size
     end
 
     def empty?
-      return @attributes['size'].zero? if api.capabilities.size_in_pages?
+      return @_attributes_['size'].zero? if api.capabilities.size_in_pages?
+
       all.empty?
     end
 
@@ -30,16 +32,15 @@ module Sequencescape::Api::Associations::HasMany
 
     def initialize(owner, json = nil)
       super
-      @cached_all = case
-        when json.is_a?(Array) then json.map {|js| new_from(js) }
-        else nil
-        end
+      @cached_all = case json
+                    when Array then json.map { |js| new_from(js) }
+                    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)
+      case json
+      when String then new(uuid: json) # We've recieved an array of strings, prob. uuids
+      when Hash then new(json)
       else json
       end
     end
@@ -60,8 +61,8 @@ module Sequencescape::Api::Associations::HasMany
       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)) }
+        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
@@ -90,7 +91,7 @@ module Sequencescape::Api::Associations::HasMany
       @objects
     end
 
-    def each_page(&block)
+    def each_page
       yield(@objects)
     end
 
@@ -105,7 +106,7 @@ module Sequencescape::Api::Associations::HasMany
     end
   end
 
-  def has_many(association, options = {}, &block)
+  def has_many(association, options = {}, &block) # rubocop:todo Metrics/MethodLength
     association = association.to_sym
 
     proxy = Class.new(

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

@@ -4,7 +4,7 @@ module Sequencescape::Api::Associations::HasMany::Json
   end
 
   def as_json(options = nil)
-    options = { :root => false, :uuid => true }.reverse_merge(options || {})
+    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

@@ -31,7 +31,7 @@ module Sequencescape::Api::Associations::HasMany::Validation
 
     def map_errors(&block)
       @association.map(&:errors)
-        .map(&block)
+                  .map(&block)
     end
   end
 end

data/lib/sequencescape-api/composition.rb

@@ -11,26 +11,30 @@ module Sequencescape::Api::Composition
     end
 
     def initialize(owner, attributes)
-      @owner, @attributes = owner, attributes
-      attributes.each { |k,v| send(:"#{k}=", v) }
+      @owner = owner
+      @_attributes_ = attributes
+      attributes.each { |k, v| send(:"#{k}=", v) }
     end
 
-    attr_reader :attributes
-    private :attributes
+    private
+
+    def attributes
+      @_attributes_
+    end
   end
 
-  def composed_of(name, options = {})
+  def composed_of(name, options = {}) # rubocop:todo Metrics/MethodLength
     composed_class_name = options[:class_name] || name
 
     line = __LINE__ + 1
-    class_eval(%Q{
+    class_eval(%{
       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
+        @_attributes_[#{name.to_s.inspect}] = attributes
       end
     }, __FILE__, line)
   end

data/lib/sequencescape-api/connection_factory.rb

@@ -8,14 +8,14 @@ class Sequencescape::Api::ConnectionFactory
   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(:url)    if default_url.blank?
 
-    required_options.push(:allow_blank => false)
+    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
+    options[:url] ||= default_url
     new(options)
   end
 
@@ -23,7 +23,9 @@ class Sequencescape::Api::ConnectionFactory
   private :url, :cookie, :read_timeout
 
   def initialize(options)
-    @url, @cookie, @authorisation = options[:url], options[:cookie], options[:authorisation]
+    @url = options[:url]
+    @cookie = options[:cookie]
+    @authorisation = options[:authorisation]
     @read_timeout = options[:read_timeout] || 120
   end
   private_class_method :initialize
@@ -37,4 +39,3 @@ class Sequencescape::Api::ConnectionFactory
 
   include Actions
 end
-

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

@@ -8,7 +8,7 @@ BEGIN {
   Net::HTTP.module_eval do
     alias_method '__initialize__', 'initialize'
 
-    def initialize(*args,&block)
+    def initialize(*args, &block)
       __initialize__(*args, &block)
     ensure
       @debug_output = $stderr if ENV['HTTP_DEBUG']
@@ -47,8 +47,9 @@ module Sequencescape::Api::ConnectionFactory::Actions
     end
   end
 
-  def create(url, body, handler)
-    perform(:post, url, jsonify(body, :action => :create)) do |response|
+  # rubocop:todo Metrics/MethodLength
+  def create(url, body, handler) # rubocop:todo Metrics/CyclomaticComplexity
+    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!
@@ -60,8 +61,10 @@ module Sequencescape::Api::ConnectionFactory::Actions
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
-  def create_from_file(url, file, filename, content_type, handler)
+  # rubocop:todo Metrics/MethodLength
+  def create_from_file(url, file, filename, content_type, handler) # rubocop:todo Metrics/CyclomaticComplexity
     perform_for_file(:post, url, file, filename, content_type) do |response|
       case response
       when Net::HTTPCreated             then handler.success(parse_json_from(response))
@@ -74,9 +77,10 @@ module Sequencescape::Api::ConnectionFactory::Actions
       end
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   def update(url, body, handler)
-    perform(:put, url, jsonify(body, :action => :update)) do |response|
+    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))
@@ -95,7 +99,7 @@ module Sequencescape::Api::ConnectionFactory::Actions
   end
   private :handle_redirect
 
-  def perform(http_verb, url, body = nil, accepts = nil, &block)
+  def perform(http_verb, url, body = nil, accepts = nil) # rubocop:todo Metrics/MethodLength
     begin
       uri = URI.parse(url)
     rescue URI::InvalidURIError => e
@@ -103,12 +107,12 @@ module Sequencescape::Api::ConnectionFactory::Actions
     end
     Net::HTTP.start(uri.host, uri.port) do |connection|
       connection.read_timeout = read_timeout
-      request_headers =  headers
+      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         = body.to_json
         request.body         = Yajl::Encoder.encode(body)
       end
       yield(connection.request(request))
@@ -116,14 +120,14 @@ module Sequencescape::Api::ConnectionFactory::Actions
   end
   private :perform
 
-  def perform_for_file(http_verb, url, file, filename, content_type, &block)
+  def perform_for_file(http_verb, url, file, filename, content_type)
     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}\""})
+      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         = body.to_json
       request.body         = file.read
       yield(connection.request(request))
     end
@@ -134,13 +138,14 @@ module Sequencescape::Api::ConnectionFactory::Actions
     case
     when body.nil?        then {}
     when body.is_a?(Hash) then body
-    else                       body.as_json(options.merge(:root => true))
+    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

data/lib/sequencescape-api/core.rb

@@ -10,7 +10,8 @@ class Sequencescape::Api
   extend Sequencescape::Api::ConnectionFactory::Helpers
 
   def initialize(options = {})
-    @models, @model_namespace = {}, options.delete(:namespace) || Sequencescape
+    @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)
@@ -18,7 +19,8 @@ class Sequencescape::Api
   end
 
   attr_reader :capabilities
-  delegate :read, :create, :create_from_file, :update, :retrieve, :to => :@connection
+
+  delegate :read, :create, :create_from_file, :update, :retrieve, to: :@connection
 
   def read_uuid(uuid, handler)
     read(@connection.url_for_uuid(uuid), handler)
@@ -30,22 +32,25 @@ class Sequencescape::Api
 
   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)
+  def model(name) # rubocop:todo Metrics/MethodLength
     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
+  rescue NameError => e
     raise if @model_namespace == ::Sequencescape
-    parts.inject([ ::Sequencescape, @model_namespace ]) do |(source, dest), part|
+
+    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) ]
+        [const_from_source, dest.const_get(part)]
       else
-        [ const_from_source, dest.const_set(part, const_from_source) ]
+        [const_from_source, dest.const_set(part, const_from_source)]
       end
     end.last
   end

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

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

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

@@ -1,14 +1,14 @@
 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)
+  def required!(*keys)
     options = keys.extract_options!
     return if keys.empty?
 
-    allowance_method = (options[:allow_blank] == false) ? :blank? : :nil?
+    allowance_method = options[:allow_blank] == false ? :blank? : :nil?
 
     missing = keys.inject([]) do |missing, next_key|
-      missing.tap do 
+      missing.tap do
         value = self[next_key]
         missing << next_key if value.send(allowance_method)
       end