syncano 4.0.0.alpha4 → 4.0.0.pre

data/lib/syncano/resources/paths.rb

@@ -1,48 +0,0 @@
-require 'singleton'
-
-module Syncano
-  module Resources
-    class Paths
-      include Singleton
-
-      attr_accessor :collections, :members
-
-      def initialize
-        self.collections = self.class::Collection.new
-        self.members = self.class::Member.new
-      end
-
-      private
-
-      class Collection
-        def initialize
-          @map = {}
-        end
-
-        def define(path, resource)
-          @map[Regexp.new("\\A#{path.gsub(/{[^}]*}/, '([^\/]+)')}\\z")] = resource
-        end
-
-        def match(path)
-          _, resouce = @map.find { |pattern, _| pattern =~ path }
-          resouce
-        end
-      end
-
-      class Member
-        def initialize
-          @map = {}
-        end
-
-        def define(path, resource)
-          resource_name = resource.name
-          @map[resource_name] = path
-        end
-
-        def find(resource)
-          @map[resource.name]
-        end
-      end
-    end
-  end
-end

data/lib/syncano/resources/resource_invalid.rb

@@ -1,15 +0,0 @@
-module Syncano
-  module Resources
-    class ResourceInvalid < StandardError
-      attr_accessor :resource
-
-      def initialize(resource)
-        self.resource = resource
-      end
-
-      def to_s
-        "#{self.class.name} <#{resource.class.name} #{resource.errors.full_messages}>"
-      end
-    end
-  end
-end

data/lib/syncano/response.rb

@@ -1,55 +0,0 @@
-module Syncano
-  class Response
-    class << self
-      def handle(raw_response)
-        code = unify_code(raw_response)
-
-        case code
-          when Status.no_content
-          when Status.successful
-            parse_response raw_response
-          when Status.not_found
-            raise NotFound.new(raw_response.env.url, raw_response.env.method)
-          when Status.client_error
-            raise ClientError.new raw_response.body, raw_response
-          when Status.server_error
-            raise ServerError.new raw_response.body, raw_response
-          else
-            raise UnsupportedStatusError.new raw_response
-        end
-      end
-
-      def parse_response(raw_response)
-        JSON.parse(raw_response.body)
-      end
-
-      def unify_code(raw_response)
-        raw_response.status.code
-      end
-    end
-
-    class Status
-      class << self
-        def successful
-          ->(code) { (200...300).include? code }
-        end
-
-        def client_error
-          ->(code) { (400...500).include? code }
-        end
-
-        def no_content
-          ->(code) { code == 204 }
-        end
-
-        def server_error
-          ->(code) { code >= 500 }
-        end
-
-        def not_found
-          ->(code) { code == 404 }
-        end
-      end
-    end
-  end
-end

data/lib/syncano/schema/endpoints_whitelist.rb

@@ -1,40 +0,0 @@
-module Syncano
-  class Schema
-    class EndpointsWhitelist
-      include Enumerable
-
-      class SupportedDefinitionPredicate
-        attr_accessor :definition
-
-        def initialize(definition)
-          self.definition = definition
-        end
-
-        def call
-          path =~ /\A\/v1\/instances/ && path !~ /invitation/
-        end
-
-        private
-
-        def path
-          definition[:collection] && definition[:collection][:path] ||
-            definition[:member] && definition[:member][:path]
-        end
-      end
-
-      SUPPORTED_DEFINITIONS = -> (definition) {
-        SupportedDefinitionPredicate.new(definition).call
-      }
-
-      def initialize(schema)
-        @definition = schema.definition
-      end
-
-      def each(&block)
-        @definition.select { |_name, definition|
-          SUPPORTED_DEFINITIONS === definition
-        }.each &block
-      end
-    end
-  end
-end

data/lib/syncano/upload_io.rb

@@ -1,7 +0,0 @@
-module Syncano
-  class UploadIO < Faraday::UploadIO
-    def initialize(path)
-      super path, File.mime_type?(File.new(path))
-    end
-  end
-end

data/spec/unit/resources/paths_spec.rb

@@ -1,21 +0,0 @@
-require_relative '../../spec_helper'
-
-describe ::Syncano::Resources::Paths do
-  let(:koza) { double 'KozaClass' }
-
-  context 'collections' do
-    subject { described_class.instance.collections }
-
-    before { subject.define '/kozas/{koza_name}/kiszkas/', koza }
-
-    specify { expect(subject.match('/kozas/mykoza/kiszkas/')).to eq(koza) }
-  end
-
-  context 'members' do
-    subject { described_class.instance.members }
-
-    before { subject.define '/kozas/{koza_name}/', koza }
-
-    xspecify { expect(subject.match('kozas/mykoza/')).to eq(koza) }
-  end
-end

data/spec/unit/response_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Syncano::Response do
-  describe '.handle' do
-    context 'success' do
-      let(:raw_response) { double :raw_response,
-                                  body: generate_body(some: 'response'),
-                                  status: status(200) }
-
-      specify do
-        expect(described_class.handle(raw_response)).to eq('some' => 'response')
-      end
-    end
-
-    context 'not found' do
-      let(:env) { double :env, url: 'http://path', method: :get }
-      let(:raw_response) { double :raw_response,
-                                  body: nil,
-                                  status: status(404),
-                                  env: env }
-
-      specify do
-        expect { described_class.handle(raw_response) }.to raise_error(Syncano::NotFound)
-      end
-    end
-
-    context 'client error' do
-      let(:raw_response) {
-        double :raw_response, body: generate_body({name: ['This field can not be "koza"']}),
-          status: status(400)
-      }
-
-      specify do
-        expect { described_class.handle(raw_response) }.to raise_error(Syncano::ClientError)
-      end
-    end
-
-    context 'returning a server error' do
-      let(:raw_response) { double :raw_response,
-                                  body: 'server error',
-                                  status: status(500) }
-
-      specify do
-        expect { described_class.handle(raw_response) }.
-          to raise_error(Syncano::ServerError)
-      end
-    end
-
-    context 'unsupported status code' do
-      let(:raw_response) { double :raw_response,
-                            body: 'fafarafa',
-                            status: status(112) }
-
-      specify do
-        expect { described_class.handle(raw_response) }.to raise_error(Syncano::UnsupportedStatusError)
-      end
-    end
-
-    context 'successful returning empty body' do
-      let(:raw_response) { double :raw_response, status: status(204) }
-
-      specify do
-        expect(described_class.handle(raw_response)).to eq(nil)
-      end
-    end
-  end
-
-  def generate_body(params)
-    JSON.generate params
-  end
-
-  def status(code)
-    double :status, code: code
-  end
-end

data/spec/unit/schema/attribute_definition_spec.rb

@@ -1,18 +0,0 @@
-require_relative  '../../spec_helper'
-
-describe Syncano::Schema::AttributeDefinition do
-  let(:name) { 'example' }
-  let(:raw_definition) { {} }
-
-  subject { described_class.new name, raw_definition }
-
-  specify { expect(subject.name).to eq(name) }
-
-  context 'when name is "class"' do
-    let(:name) { 'class' }
-
-    it 'should be named associated_class to avoid method name collision' do
-      expect(subject.name).to eq('associated_class')
-    end
-  end
-end