syncano 4.0.0.alpha4 → 4.0.0.pre

data/lib/syncano/schema.rb

@@ -1,26 +1,33 @@
 require_relative './schema/attribute_definition'
 require_relative './schema/resource_definition'
-require_relative './schema/endpoints_whitelist'
-
-require 'singleton'
 
 module Syncano
   class Schema
+    SCHEMA_PATH = 'schema/'
 
     attr_reader :schema
 
-    def self.schema_path
-      "/#{Syncano::Connection::API_VERSION}/schema/"
+    def initialize(connection)
+      self.connection = connection
+      load_schema
     end
 
-    def initialize(connection = ::Syncano::Connection.new)
-      self.connection = connection
+    def process!
+      schema.each do |resource_name, resource_definition|
+        self.class.generate_resource_class(resource_name, resource_definition)
+        if resource_definition[:collection].present? && resource_definition[:collection][:path].scan(/\{([^}]+)\}/).empty?
+          self.class.generate_client_method(resource_name)
+        end
+      end
     end
 
+    private
+
     attr_accessor :connection
+    attr_writer :schema
 
-    def definition
-      raw_schema = connection.request(:get, self.class.schema_path)
+    def load_schema
+      raw_schema = connection.request(:get, SCHEMA_PATH)
       resources = {}
 
       raw_schema.each do |resource_schema|
@@ -61,7 +68,149 @@ module Syncano
         end
       end
 
-      resources
+      self.schema = resources
+    end
+
+    def self.generate_resource_class(name, definition_hash)
+      delete_colliding_links definition_hash
+
+      resource_definition = ::Syncano::Schema::ResourceDefinition.new(definition_hash)
+      resource_class = new_resource_class(resource_definition, name)
+
+      ::Syncano::Resources.const_set(name, resource_class)
+    end
+
+    def self.delete_colliding_links(definition)
+      definition[:attributes].each do |k, v|
+        definition[:associations]['links'].delete_if { |link| link['name'] == k } if definition[:associations]['links']
+      end
+    end
+
+    def self.new_resource_class(definition, name)
+      attributes_definitions = []
+
+      definition[:attributes].each do |attribute_name, attribute|
+        attributes_definitions << {
+            name: attribute_name,
+            type: map_syncano_attribute_type(attribute['type']),
+            default: attribute_name != 'channel' ? default_value_for_attribute(attribute) : nil,
+            presence_validation: attribute['required'],
+            length_validation_options: extract_length_validation_options(attribute),
+            inclusion_validation_options: extract_inclusion_validation_options(attribute),
+            create_writeable: attribute['read_only'] == false,
+            update_writeable: attribute['read_only'] == false,
+        }
+      end
+
+      ::Class.new(::Syncano::Resources::Base) do
+        self.create_writable_attributes = []
+        self.update_writable_attributes = []
+
+        attributes_definitions.each do |attribute_definition|
+          attribute attribute_definition[:name], type: attribute_definition[:type], default: attribute_definition[:default], force_default: !attribute_definition[:default].nil?
+          validates attribute_definition[:name], presence: true if attribute_definition[:presence_validation]
+          validates attribute_definition[:name], length: attribute_definition[:length_validation_options]
+
+          if attribute_definition[:inclusion_validation_options]
+            validates attribute_definition[:name], inclusion: attribute_definition[:inclusion_validation_options]
+          end
+
+          self.create_writable_attributes << attribute_definition[:name].to_sym if attribute_definition[:create_writeable]
+          self.update_writable_attributes << attribute_definition[:name].to_sym if attribute_definition[:update_writeable]
+        end
+
+        if name == 'Object' #TODO: extract to a separate module + spec
+          attribute :custom_attributes, type: ::Object, default: nil, force_default: true
+
+          def attributes=(new_attributes)
+            super
+
+            self.custom_attributes = new_attributes.select { |k, v| !self.class.attributes.keys.include?(k) }
+          end
+
+          def method_missing(method_name, *args, &block)
+            if method_name.to_s =~ /=$/
+              custom_attributes[method_name.to_s.gsub(/=$/, '')] = args.first
+            else
+              if custom_attributes.has_key? method_name.to_s
+                custom_attributes[method_name]
+              else
+                super
+              end
+            end
+          end
+        end
+
+        (definition[:associations]['links'] || []).each do |association_schema|
+          if association_schema['type'] == 'list'
+            define_method(association_schema['name']) do
+              has_many_association(association_schema['name'])
+            end
+          elsif association_schema['type'] == 'detail' && association_schema['name'] != 'self'
+            define_method(association_schema['name']) do
+              belongs_to_association(association_schema['name'])
+            end
+          elsif association_schema['type'] == 'run'
+            define_method(association_schema['name']) do |config = nil|
+              custom_method association_schema['name'], config
+            end
+          end
+        end
+
+        private
+
+        self.resource_definition = definition
+      end
+    end
+
+    def self.generate_client_method(resource_name)
+      method_name = resource_name.tableize
+      resource_class = "::Syncano::Resources::#{resource_name}".constantize
+
+      ::Syncano::API.send(:define_method, method_name) do
+        ::Syncano::QueryBuilder.new(connection, resource_class)
+      end
+    end
+
+    def self.extract_length_validation_options(attribute_definition)
+      maximum = begin
+        Integer attribute_definition['max_length']
+      rescue TypeError, ArgumentError
+      end
+
+      { maximum: maximum } unless maximum.nil?
+    end
+
+    def self.extract_inclusion_validation_options(attribute_definition)
+      return unless choices = attribute_definition['choices']
+
+      { in: choices.map { |choice| choice['value'] } }
+    end
+
+    def self.map_syncano_attribute_type(type)
+      mapping = HashWithIndifferentAccess.new(
+        string: ::String,
+        email: ::String,
+        choice: ::String,
+        slug: ::String,
+        integer: ::Integer,
+        float: ::Float,
+        date: ::Date,
+        datetime: ::DateTime,
+        field: ::Object
+      )
+
+      type.present? ? mapping[type] : Object
+    end
+
+    def self.default_value_for_attribute(attribute)
+      if attribute['type'].present? && attribute['type'].to_sym == :field
+        {}
+      elsif attribute['type'].present? && attribute['type'].to_sym == :choice
+        attribute['choices'].first['value']
+      else
+        nil
+      end
     end
   end
 end

data/lib/syncano/schema/attribute_definition.rb

@@ -1,82 +1,7 @@
 module Syncano
   class Schema
     class AttributeDefinition
-      attr_accessor :name, :type, :default
-
-      TYPES_MAPPING = { 'string' => ::String,
-                        'email' => ::String,
-                        'choice' => ::String,
-                        'slug' => ::String,
-                        'integer' => ::Integer,
-                        'float' => ::Float,
-                        'date' => ::Date,
-                        'datetime' => ::DateTime,
-                        'field' => ::Object }
-
       def initialize(name, raw_definition)
-        # TODO implement #original_name to send request with correct parameters
-        self.name = name == 'class' ? 'associated_class' : name
-        self.raw_definition = raw_definition
-
-        set_type
-        set_default
-      end
-
-      def validate?
-        writable? && required?
-      end
-
-      def writable?
-        raw_definition['read_only'] == false
-      end
-
-      def required?
-        raw_definition['required'] == true
-      end
-
-      def required_length
-        begin
-          { maximum: Integer(raw_definition['max_length']) }
-        rescue TypeError, ArgumentError
-        end
-      end
-
-      def required_values_inclusion
-        return unless choices = raw_definition['choices']
-
-        { in: choices.map { |choice| choice['value'] } }
-      end
-
-      alias :updatable? :writable?
-
-      def [](key)
-        raw_definition[key]
-      end
-
-      private
-
-      attr_accessor :raw_definition
-
-      def set_type
-        self.type = if %w[owner group].include?(name)
-                      ::Integer
-                    elsif raw_definition['type'].blank?
-                      ::Object
-                    else
-                      TYPES_MAPPING[raw_definition['type']]
-                    end
-      end
-
-      def set_default
-        self.default = if name == 'channel'
-                         nil
-                       elsif raw_definition['type'].present? && raw_definition['type'].to_sym == :field
-                         {}
-                       elsif raw_definition['type'].present? && raw_definition['type'].to_sym == :choice
-                         raw_definition['choices'].try(:first).try :[], 'value'
-                       else
-                         nil
-                       end
       end
     end
   end

data/lib/syncano/schema/resource_definition.rb

@@ -2,40 +2,18 @@ module Syncano
   class Schema
     class ResourceDefinition
       attr_accessor :attributes
-      attr_accessor :name
 
-      def initialize(name, raw_defitnition)
+      def initialize(raw_defitnition)
         @raw_definition = raw_defitnition
 
-        delete_colliding_links
-
-        self.name = name
-
         self.attributes = raw_defitnition[:attributes].map do |name, raw_attribute_definition|
-          Syncano::Schema::AttributeDefinition.new name, raw_attribute_definition
+          AttributeDefinition.new name, raw_attribute_definition
         end
       end
 
       def [](key)
         @raw_definition[key]
       end
-
-      def top_level?
-        @raw_definition[:collection].present? &&
-          @raw_definition[:collection][:path].scan(/\{([^}]+)\}/).empty?
-      end
-
-      private
-
-      def delete_colliding_links
-        @raw_definition[:attributes].each do |k, v|
-          if @raw_definition[:associations]['links']
-            @raw_definition[:associations]['links'].delete_if do |link|
-              link['name'] == k
-            end
-          end
-        end
-      end
     end
   end
 end

data/lib/syncano/version.rb

@@ -1,3 +1,3 @@
 module Syncano
-  VERSION = '4.0.0.alpha4'
+  VERSION = '4.0.0.pre'
 end

data/spec/integration/syncano_spec.rb

@@ -4,32 +4,29 @@ WebMock.allow_net_connect!
 
 describe Syncano do
   before(:all) do
-    Syncano::API.send :initialized=, false
-
     @api_key = ENV['INTEGRATION_TEST_API_KEY']
     @api = Syncano.connect(api_key: @api_key)
   end
 
   before(:each) do
     @api.instances.all.each &:destroy
-    @instance = @api.instances.create(name: instance_name )
+    @instance = @api.instances.create(name: "a#{@api_key}")
     @instance.classes.all.select { |c| c.name != 'user_profile'}.each &:destroy
     @instance.groups.all.each &:destroy
     @instance.users.all.each &:delete
   end
 
-  let(:instance_name) { "a#{SecureRandom.hex(24)}" }
   let(:group) { @instance.groups.create name: 'wheel' }
 
   describe 'working with instances' do
     subject { @api.instances }
 
     it 'should raise an error on not found instance' do
-      expect { subject.find('kaszanka') }.to raise_error(Syncano::NotFound)
+      expect { subject.find('kaszanka') }.to raise_error(Syncano::ClientError)
     end
 
     specify do
-      subject.create name: 'fafarafaa'
+      subject.create name: 'fafarafa'
     end
   end
 
@@ -37,7 +34,7 @@ describe Syncano do
     subject { @instance.classes }
 
     specify do
-      expect { subject.create name: 'sausage', schema: [{name: 'name', type: 'string' }] }.to create_resource
+      expect { subject.create name: 'sausage', schema: [{name: 'name', type: 'string' }], group: group.primary_key }.to create_resource
 
       new_klass = subject.last
 
@@ -60,15 +57,18 @@ describe Syncano do
 
   describe 'working with objects' do
     before do
+      @owner = @instance.users.create username: 'admin', password: 'dupa.8'
       @class = @instance.classes.create name: 'account',
+                                        group: group.primary_key,
                                         schema: [{name: 'currency', type: 'string', filter_index: true},
                                                  {name: 'ballance', type: 'integer', filter_index: true, order_index: true}]
     end
 
     subject { @class.objects }
 
+
     specify 'basic operations' do
-      expect { subject.create currency: 'USD', ballance: 1337 }.to create_resource
+      expect { subject.create currency: 'USD', ballance: 1337, group: group.primary_key, owner: @owner.primary_key }.to create_resource
 
       object = subject.first
 
@@ -82,63 +82,25 @@ describe Syncano do
       expect(object.ballance).to eq(54)
       expect(object.currency).to eq('GBP')
 
-      expect { subject.destroy(object.primary_key) }.to destroy_resource
-    end
-
-
-    specify 'PATH and POST' do
-      initial_yuan = subject.create currency: 'CNY', ballance: 98123
-
-      yuan = subject.first
-      new_yuan = subject.first
-
-      yuan.ballance = 100000
-      yuan.save
-
-      new_yuan.currency = 'RMB'
-      new_yuan.save
-
-      yuan = subject.first
-
-      expect(yuan.currency).to eq('RMB')
-      expect(yuan.ballance).to eq(100000)
-
-      initial_yuan.save(overwrite: true)
-      yuan.reload!
-
-      expect(yuan.currency).to eq('CNY')
-      expect(yuan.ballance).to eq(98123)
+      expect { object.destroy }.to destroy_resource
     end
 
     specify 'filtering and ordering' do
-      usd = subject.create(currency: 'USD', ballance: 400)
-      pln = subject.create(currency: 'PLN', ballance: 1600)
-      eur = subject.create(currency: 'EUR', ballance: 400)
-      gbp = subject.create(currency: 'GPB', ballance: 270)
-      chf = subject.create(currency: 'CHF', ballance: 390)
-      uah = subject.create(currency: 'UAH', ballance: 9100)
-      rub = subject.create(currency: 'RUB')
+      usd = subject.create(currency: 'USD', ballance: 400, group: group.primary_key, owner: @owner.primary_key)
+      pln = subject.create(currency: 'PLN', ballance: 1600, group: group.primary_key, owner: @owner.primary_key)
+      eur = subject.create(currency: 'EUR', ballance: 400, group: group.primary_key, owner: @owner.primary_key)
+      gbp = subject.create(currency: 'GPB', ballance: 270, group: group.primary_key, owner: @owner.primary_key)
+      chf = subject.create(currency: 'CHF', ballance: 390, group: group.primary_key, owner: @owner.primary_key)
+      uah = subject.create(currency: 'UAH', ballance: 9100, group: group.primary_key, owner: @owner.primary_key)
+      rub = subject.create(currency: 'RUB', group: group.primary_key, owner: @owner.primary_key)
 
       expect(subject.all(query: { ballance: { _exists: true }}).to_a).to_not include(rub)
       expect(subject.all(query: { currency: { _in: %w[UAH USD PLN] } }).to_a).to match_array([pln, usd, uah])
       expect(subject.all(query: { ballance: { _lt: 400, _gte: 270 }}, order_by: '-ballance').to_a).to eq([chf, gbp])
     end
 
-    specify 'fetching only specific fields' do
-      subject.create(currency: 'USD', ballance: 400)
-
-      account = subject.all(fields: 'currency').first
-      expect { account.currency }.to_not raise_error
-      expect { account.ballance }.to raise_error(NoMethodError)
-
-
-      account = subject.first(excluded_fields: 'currency')
-      expect { account.currency }.to raise_error(NoMethodError)
-      expect { account.ballance }.to_not raise_error
-    end
-
     specify 'paging', slow: true do
-      104.times { subject.create }
+      104.times { subject.create group: group.primary_key, owner: @owner.primary_key }
 
       total = 0
       all = subject.all
@@ -162,7 +124,7 @@ describe Syncano do
 
 
     specify 'basic operations' do
-      expect { subject.create label: 'df', source: 'puts 1337', runtime_name: 'ruby' }.to create_resource
+      expect { subject.create name: 'df', source: 'puts 1337', runtime_name: 'ruby' }.to create_resource
 
       codebox = subject.first
       codebox.run
@@ -170,7 +132,7 @@ describe Syncano do
       codebox.save
       codebox.run
 
-      without_profiling { sleep 10 }
+      without_profiling { sleep 5 }
       traces = codebox.traces.all
 
       expect(traces.count).to eq(2)
@@ -178,13 +140,13 @@ describe Syncano do
       first = traces[1]
 
       expect(first.status).to eq('success')
-      expect(first.result["stdout"]).to eq('1337')
+      expect(first.result).to eq('1337')
 
       second = traces[0]
       expect(second.status).to eq('success')
-      expect(second.result["stdout"]).to eq('123')
+      expect(second.result).to eq('123')
 
-      expect { @instance.schedules.create label: 'test', interval_sec: 30, codebox: codebox.primary_key }.
+      expect { @instance.schedules.create name: 'test', interval_sec: 30, codebox: codebox.primary_key }.
           to change { @instance.schedules.all.count }.by(1)
 
       expect { codebox.destroy }.to destroy_resource
@@ -194,218 +156,14 @@ describe Syncano do
   describe 'working with webhooks' do
     subject { @instance.webhooks }
 
-    describe 'using the gem' do
-      let!(:codebox) { @instance.codeboxes.create label: 'wurst', source: 'puts "currywurst"', runtime_name: 'ruby' }
-
-      specify do
-        expect { subject.create name: 'web-wurst', codebox: codebox.primary_key }.to create_resource
-
-        expect(subject.first.run['result']["stdout"]).to eq('currywurst')
-
-        expect { subject.first.destroy }.to destroy_resource
-      end
-    end
-
-    describe 'using curl' do
-      let(:source) {
-        <<-SOURCE
-          p ARGS["POST"]
-        SOURCE
-      }
-      let!(:codebox) { @instance.codeboxes.create label: 'curl', source: source, runtime_name: 'ruby' }
-      let!(:webhook) { subject.create name: 'web-curl', codebox: codebox.primary_key, public: true }
-
-      specify do
-        url = "#{ENV['API_ROOT']}/v1/instances/#{instance_name}/webhooks/p/#{webhook.public_link}/"
-        code = %{curl -k --form kiszka=koza -H "kiszonka: 007" -X POST #{url} 2>/dev/null}
-        output = JSON.parse(`#{code}`)
-
-        expect(output["status"]).to eq("success")
-        expect(output["result"]["stdout"]).to eq('{"kiszka"=>"koza"}')
-      end
-    end
-  end
-
-  describe 'working with API keys' do
-    subject { @instance.api_keys }
-
-    specify do
-      api_key = nil
-
-      expect {
-        api_key = subject.create allow_user_create: true
-      }.to create_resource
-
-      expect { api_key.destroy }.to destroy_resource
-    end
-  end
-
-  describe 'managing users' do
-    subject { @instance.users }
-
-    let(:user_profile) { @instance.classes.find("user_profile") }
-
-    before do
-      user_profile.schema = [{ name: "nickname", type: "text" },
-                             { name: "resume", type: "file" }]
-      user_profile.save
-    end
+    let!(:codebox) { @instance.codeboxes.create name: 'wurst', source: 'puts "currywurst"', runtime_name: 'ruby' }
 
     specify do
-      user = nil
-
-      expect {
-        user = subject.create(username: 'koza', password: 'kiszkakoza')
-      }.to create_resource
-
-      user.update_attributes username: 'kiszka'
-      expect(subject.find(user.primary_key).username).to eq('kiszka')
-
-
-      profile =  @instance.classes.find("user_profile").objects.find(1)
-      profile.nickname = "k0z4"
-      profile.resume = Syncano::UploadIO.new(File.absolute_path(__FILE__))
-      profile.save
-
-      expect(profile.nickname).to eq("k0z4")
-
-      expect { user.destroy }.to destroy_resource
-    end
-  end
-
-
-  describe 'managing groups' do
-    subject { @instance.groups }
-
-    specify do
-      creator = @instance.users.create username: 'content', password: 'creator'
-
-      content_creators = nil
-
-      expect {
-        content_creators = subject.create label: 'content creators'
-      }.to create_resource
-
-      expect {
-        content_creators.users.create user: creator.primary_key
-      }.to change { content_creators.users.all.count }.from(0).to(1)
-
-      expect { content_creators.destroy }.to destroy_resource
-    end
-  end
-
-  describe 'managing channels' do
-    subject do
-      @instance.channels
-    end
-
-    specify do
-      channel = nil
-      expect { channel = subject.create(name: 'chat') }.to create_resource
-      expect { channel.destroy }.to destroy_resource
-    end
-  end
-
-
-  describe 'subscribing to a channel' do
-    before(:each) { Celluloid.boot }
-
-    after(:each) { Celluloid.shutdown }
-
-    let!(:notifications) do
-      @instance.classes.create(name: 'notifications', schema: [{name: 'message', type: 'string'}]).objects
-    end
-
-    let!(:notifications_channel) do
-      @instance.channels.create name: 'system-notifications', other_permissions: 'subscribe'
-    end
-
-    specify do
-      poller = notifications_channel.poll
-
-      notification = notifications.create(message: "A new koza's arrived", channel: 'system-notifications')
-
-      sleep 20
-
-      expect(poller.responses.size).to eq(1)
-      expect(JSON.parse(poller.responses.last.body)["payload"]["message"]).to eq("A new koza's arrived")
-
-      notification.message = "A koza's gone"
-      notification.save
-
-      sleep 20
-
-      expect(poller.responses.size).to eq(2)
-      expect(JSON.parse(poller.responses.last.body)["payload"]["message"]).to eq("A koza's gone")
-
-      poller.terminate
-    end
-  end
-
-  describe 'subscribing to a room' do
-    before(:each) { Celluloid.boot }
-
-    after(:each) { Celluloid.shutdown }
-
-    let!(:house) {
-      @instance.channels.create name: 'house', type: 'separate_rooms', other_permissions: 'publish', custom_publish: true
-    }
-    let!(:shout) {
-      @instance.classes.create name: 'shout', schema: [{name: 'message', type: 'string'}]
-    }
-
-    specify do
-      shout.objects.create channel: 'house', channel_room: 'bathroom', message: "Where's the water?"
-      shout.objects.create channel: 'house', channel_room: 'basement', message: "Where's the light?"
-
-      expect(house.history.all(room: 'bathroom').count).to eq(1)
-      expect(house.history.all(room: 'basement').count).to eq(1)
-      expect(house.history.all.count).to eq(2)
-    end
-  end
-
-  describe 'using syncano on behalf of the user' do
-    let(:user_api_key) { @instance.api_keys.create.api_key }
-    let(:user) {
-      @instance.users.create username: 'kiszonka', password: 'passwd'
-    }
-    let(:another_user) {
-      @instance.users.create username: 'another', password: 'user'
-    }
-    let(:user_instance) {
-      Syncano.connect(api_key: user_api_key, user_key: user.user_key).
-        instances.first
-    }
-    let(:another_user_instance) {
-      Syncano.connect(api_key: user_api_key, user_key: another_user.user_key).
-        instances.first
-    }
-    let(:group) { @instance.groups.create label: 'content creators' }
-
-    before do
-      group.users.create user: user.primary_key
-      group.users.create user: another_user.primary_key
-
-      @instance.classes.create name: 'book',
-                               schema: [{ name: 'title', type: 'string' }],
-                               group: group.primary_key,
-                               group_permissions: 'create_objects'
-    end
-
-    specify do
-      owner_books = user_instance.classes.find('book').objects
-      book = owner_books.create(title: 'Oliver Twist', owner_permissions: 'write')
-
-      expect(owner_books.all.to_a).to_not be_empty
-
-      group_member_books = another_user_instance.classes.find('book').objects
-      expect(group_member_books.all.to_a).to be_empty
+      expect { subject.create slug: 'web-wurst', codebox: codebox.primary_key }.to create_resource
 
-      book.group_permissions = 'read'
-      book.group = group.primary_key
-      book.save
+      expect(subject.first.run['result']).to eq('currywurst')
 
-      expect(group_member_books.all.to_a).to_not be_empty
+      expect { subject.first.destroy }.to destroy_resource
     end
   end