nesaulov / surrealist Goto Github PK

class Country
  include Surrealist
  surrealize_with CountrySerializer

  belongs_to :region
end

class Region
  include Surrealist
  surrealize_with RegionSerializer

  has_many :countries
end

class RegionSerializer < Surrealist::Serializer
    json_schema do
      {
        name: String,
        slug: String,
        countries: Array
      }
    end

    def countries
      object.countries.to_a
    end
end

class CountrySerializer < Surrealist::Serializer
  include Location

  json_schema do
    {
      name: String,
      slug: String
    }
  end
end

Regions::RegionSerializer.new(Region.includes(:countries)).surrealize(root: :regions)

users: ArrayOf(Entities::User.defined_schema)

module SerializerMixin
  def first_field
    []
  end
end

class CompositeSerializer < Surrealist::Serializer
  include SerializerMixin

  json_schema do
    { first_field: Array, second_field: Hash, third_field: String }
  end

  def second_field
    {}
  end

  def third_field
    "awesome issue"
  end
end

class GuestSerializer < Surrealist::Serializer
  include SerializerMixin

  json_schema do
    { first_field: Array }
  end
end

GuestSerializer.new(object).build_schema

class CompositeSerializer < Surrealist::Serializer
  json_schema do
    { first_field: Array, second_field: Hash, third_field: String }
  end
 
  json_schema(:guest_user) do
    { first_field: Array }
  end

  def first_field
    []
  end

  def second_field
    {}
  end

  def third_field
    "awesome issue"
  end
end

CompositeSerializer.new(object).build_schema(:guest_user)

class HumanSerializer < Surrealist::Serializer
  json_schema do
    { name: String, name_length: Integer }
  end

  def name_length
    name.length
  end
end

class Human
  include Surrealist

  attr_reader :name

  surrealize_with HumanSerializer

  def initialize(name)
    @name = name
  end
end

Human.new('John').surrealize(camelize: true)
# => '{"name": "John", "nameLength": 4}'

HumanSerializer.new(Human.new('Alfred')).surrealize(camelize: true)
# => '{"name": "Alfred", "nameLength": 6}'

module Animal
  class Cat
    include Surrealist

    json_schema do
      { weight: String }
    end

    def weight
      '3 kilos'
    end
  end
end

Animal::Cat.new.surrealize(include_root: true)
# => '{ "cat": { "weight": "3 kilos" } }'

Animal::Cat.new.surrealize(root: :kitten)
# => '{ "kitten": { "weight": "3 kilos" } }'
Animal::Cat.new.surrealize(root: 'kitten')
# => '{ "kitten": { "weight": "3 kilos" } }'

Animal::Cat.new.surrealize(include_root: true, root: :kitten)
# => '{ "kitten": { "cat": { "weight": "3 kilos" } } }'
Animal::Cat.new.surrealize(include_namespaces: true, root: 'kitten')
# => '{ "kitten": { "animal": { "cat": { "weight": "3 kilos" } } } }'

module Business
  class Cashout
    class Reports
      class Withdraws
        include surrealist

        json_schema do
          { amount: Types::Strict::String }
        end

        def amount
          '120$'
        end
      end
    end
  end
end

withdraws = Business::Cashout::Reports::Withdraws.new

withdraws.surrealize(include_namespaces: true)
# =>  '{ "business":  { "cashout": { "reports": { "withdraws": { "amount": "120$" } } } } }'

withdraws.surrealize(include_namespaces: true, namespaces_nesting_level: 3)
# =>  '{ "cashout": { "reports": { "withdraws": { "amount": "120$" } } } }'

Foo = Struct.new(:foo, :bar)
Foo.include Surrealist
Foo.json_schema { { bar: String } }

foo = Foo.new('foo', 'bar')

foo.surrealize
# => "{\"bar\":\"bar\"}"

foo.surrealize(include_root: true)
# Surrealist::UndefinedMethodError: undefined method `bar' for "foo":String. You have probably defined a key in the schema that doesn't have a corresponding method.

foo.surrealize(root: 'foo')
# Surrealist::UndefinedMethodError: undefined method `bar' for "foo":String. You have probably defined a key in the schema that doesn't have a corresponding method.

foo.surrealize(root: 'fooz')
# => "{\"fooz\":{\"bar\":\"bar\"}}"

class User
  include Dry::Types.module
  include Surrealist

  json_schema do
    {
      email: Types::Coercible::String,
      age: Types::Strict::Int
    }
  end
end

class Parent
  include Surrealist

  json_schema do
    { name: String }
  end

  def name
    'Parent'
  end
end

class Child < Parent
  def name
    'Child'
  end
end

Child.new.surrealize
# => Surrealist::UnknownSchemaError: Can't serialize Child - no schema was provided.

class Child < Parent
  
  delegate_surrealization_to Parent
  
  def name
    'Child'
  end
end
Child.new.surrealize # => '{ "name": "Child" }'

class User
  include Surrealist

  attr_reader :full_name, :credit_card

  json_schema do
    {
      full_name: String,
      credit_card: Integer,
    }
  end

  def initialize(full_name:, credit_card:)
    @full_name = full_name
    @credit_card = credit_card
  end
end

user = User.new(full_name: 'John Doe', credit_card: 1234_5678_9012_3456)

user.surrealize # => "{\"full_name\":\"John Doe\",\"credit_card\":1234567890123456}"
user.surrealize(camel_case: true) # => "{\"fullName\":\"John Doe\",\"creditCard\":1234567890123456}"
# or
user.surrealize(camelize: true) # => "{\"fullName\":\"John Doe\",\"creditCard\":1234567890123456}"

class IncomeSerializer < Surrealist::Serializer
  json_schema { { amount: Integer } }
  serializer_context :current_user, :something, :else
  
  def amount
    current_user.guest? ? 100000000 : object.amount
  end
end

gem "surrealist", "1.2.0"
require "surrealist"

class KekSerializer < Surrealist::Serializer
  json_schema do
    {
      kek: String,
      cheburek: String,
    }
  end

  def kek
    "kek"
  end

  def cheburek
    "cheburek"
  end
end

class A
  def kek
    "smth"
  end
end

kek = A.new
p KekSerializer.new(kek).build_schema # => {:kek=>"smth", :cheburek=>"cheburek"}

class Cat
  include Surrealist

  json_schema do
    { weight: String }
  end

  def weight
    '3 kilos'
  end
end

Cat.new.surrealize(include_root: true)
# => '{ "cat": { "weight": "3 kilos" } }'

require 'surrealist'

class Foo
  def test
    'test'
  end
end

class FooSerializer < Surrealist::Serializer
  json_schema { { test: String } }
end

FooSerializer.new(Foo.new).build_schema

# => ArgumentError (wrong number of arguments (given 0, expected 2..3))

require 'sequel'
require 'surrealist'

FileUtils.rm('test.sqlite') if File.exists?('test.sqlite')
DB = Sequel.sqlite('test.sqlite')
DB.create_table('users') do
  primary_key :id
  String :name
end

class UserSerializer < Surrealist::Serializer
  json_schema {
    {id: Integer, name: String}
  }
end

class User < Sequel::Model
  include Surrealist

  surrealize_with UserSerializer
end

User.create(name: 'Name')

User.first.surrealize
UserSerializer.new(User.first).surrealize

class Something
  include Surrealist
  surrealize_with SomethingSerializer
  surrealize_with SomethingShortSerializer, tag: :short
end

Something.new.surrealize
Something.new.surrealize(tag: :short)

class HumanSerializer < Surrealist::Serializer
  json_schema do
    { name: String, name_length: Integer }
  end

  def name_length
    name.length
  end
end

class SmallHumanSerializer < Surrealist::Serializer
  json_schema do
    { name: String }
  end
end

class Human
  include Surrealist

  attr_reader :name

  surrealize_with HumanSerializer # default
  surrealize_with SmallHumanSerializer, tag: :small

  def initialize(name)
    @name = name
  end
end

# default behaviour
Human.new('John').surrealize(camelize: true)
# => '{"name": "John", "nameLength": 4}'

# using tags
Human.new('John').surrealize(camelize: true, tag: :small)
# => '{"name": "John"}'

class Person
  include Surrealist
 
  json_schema do
    {
      name: String,
      {avatar: :image}: String
    }
  end
 
  def name
    'John Doe'
  end
 
  def image
   'http://some-image.host/avatars/123.jpeg'
  end
end

Person.new.surrealize 
# => { name: "John Doe", avatar: "http://some-image.host/avatars/123.jpeg" }

class Foo
  include Surrealist
  json_schema do
    { foo: String }
  end
end

Foo.new({ foo: "bar" }).surrealize # crash!

class HashBased
  include Surrealist

  attr_reader :hash

  def initialize(hash = {})
    @hash = hash.deep_symbolize_keys
  end

  def method_missing(method_name, *args)
    if hash.key?(method_name)
      hash[method_name]
    else
      super
    end
  end

  def respond_to_missing?(method_name, _include_private = false)
    hash.key?(method_name)
  end
end

class Foo < HashBased
  json_schema do
    # same as before
  end
end

Foo.new({ foo: "bar" }).surrealize # now it works!

class User < ActiveRecord::Base
  include Surrealist

  json_schema do
    { id: Integer, name: String }
  end
end

Surrealist.surrealize_collection(User.all, include_root: true)
# => '{ "users": [ { "id": 1, "name": "John" }, { "id": 2, "name": "Chris" } ... ] }'

class MySerializer
  include Surrealist
  json_schema do
    { name: String, age: Int }
  end
end

get '/foo' do
  # returns json using MySerializer
  present AnyClass.get_data(params), with: MySerializer 
end

it do
  expect(AnyClass).to receive(:get_data).and_return(data)
  get '/foo'
end

{ name: "", age: 0 }

let(:data) { MySerializer.schema_sample } 

Surrealist.default_options = { camelize: true, include_root: true }