ruby-serializer 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76d0570d6c6888182f54fad8d93447115da9b15d
-  data.tar.gz: fadc5ff494af8792ba60f1c76b90cc822ed90f4c
+  metadata.gz: 64873bd0b35de8defd662d6bd92bb9b52100937e
+  data.tar.gz: a735bbb0a3e92c063bbef5be1c1b58dac515cfd2
 SHA512:
-  metadata.gz: 0d35417352d902d4e46cd7de29e7151fe6024b784f6b46a0029bf38cd4db8545c8e559f6f71a82e9d75dbcefadf3411eab517a7b60ab4dc39baa23aeaae2313a
-  data.tar.gz: 5a0ea330adc5f8ad4cdac778524677342547f30888fadadae3f527b2a685070e6f32557a8854d6a759647747638a6f60593a9224967241cda736521663ed6c35
+  metadata.gz: da5bf86ac16016adec3d8951000c0846f488408e67826afc85395bf273456854319e35289bb083377404c4863c276fa9e650ba716b34cae6e5090206ec7d6fce
+  data.tar.gz: d26a542f36175f9638a29091fe03250ae7272cacc1cff5e5a52f8ba7bf91a052ccf875921fd47f0971443f57f290ad07475e8a482563e86fb31a8c8df29538f7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-serializer (0.0.1)
+    ruby-serializer (1.0.0)
 
 GEM
   remote: http://rubygems.org/

data/lib/ruby_serializer/association.rb

@@ -0,0 +1,24 @@
+module RubySerializer
+  class Association < Field
+
+    #----------------------------------------------------------------------------------------------
+
+    def serialize(resource, serializer)
+      includes = serializer.send(:includes)[field]
+      association = resource.send(field)
+      if association
+        RubySerializer.as_json(association, include: includes)
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def present?(resource, serializer)
+      super &&
+      serializer.send(:include?, field)
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/lib/ruby_serializer/base.rb

@@ -3,8 +3,7 @@ module RubySerializer
 
     extend RubySerializer::Dsl
 
-    attr_reader :options, :include # only populated during #serialize and (temporarily) stores the #serialize options to make
-                                   # them available to any potential :value, :only and :unless lambdas in the derived serializer
+    attr_reader :options
 
     def initialize(resource)
       @resource = resource
@@ -23,6 +22,11 @@ module RubySerializer
     private
 
     attr_reader :resource
+    attr_reader :includes
+
+    def include?(association)
+      includes.key?(association.to_sym)
+    end
 
     def serialize(options = {})
       if resource.respond_to? :to_ary
@@ -40,7 +44,8 @@ module RubySerializer
     end
 
     def serialize_object(options)
-      @options = options
+      @options  = options
+      @includes = expand_includes(options[:include])
       json = {}
       json[:errors] = resource.errors if resource.respond_to?(:valid?) && !resource.valid?
       self.class.fields.each do |field|
@@ -58,5 +63,28 @@ module RubySerializer
 
     #----------------------------------------------------------------------------------------------
 
+    def expand_includes(includes, options = {})
+
+      return includes if includes.is_a?(Hash) # already expanded
+
+      includes = case includes
+                 when nil    then []
+                 when Array  then includes
+                 when Symbol then [ includes ]
+                 when String then includes.split(',')
+                 else
+                   raise ArgumentError, "unexpected includes #{includes.class}"
+                 end
+
+      includes.each_with_object({}) do |i, hash|
+        i.to_s.downcase.strip.split('.').reduce(hash) do |h, part|
+          h[part.to_sym] ||= {}
+        end
+      end
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
   end
 end

data/lib/ruby_serializer/dsl.rb

@@ -1,6 +1,8 @@
 module RubySerializer
   module Dsl
 
+    #----------------------------------------------------------------------------------------------
+
     def serializes(name)
       define_method(name) do   # provide a friendly-name accessor to the underlying resource
         resource
@@ -11,8 +13,17 @@ module RubySerializer
       fields << Field.new(field, namespace, options)
     end
 
-    def fields
-      @fields ||= []
+    def belongs_to(field, options = {})
+      fields << Field.new("#{field}_id", namespace, options)
+      fields << Association.new(field, namespace, options)
+    end
+
+    def has_many(field, options = {})
+      fields << Association.new(field, namespace, options)
+    end
+
+    def has_one(field, options = {})
+      fields << Association.new(field, namespace, options)
     end
 
     def namespace(ns = nil, &block)
@@ -23,5 +34,11 @@ module RubySerializer
       @namespace.pop
     end
 
+    def fields
+      @fields ||= []
+    end
+
+    #----------------------------------------------------------------------------------------------
+
   end
 end

data/lib/ruby_serializer/field.rb

@@ -5,8 +5,8 @@ module RubySerializer
 
     def initialize(field, namespace, options)
       @field     = field.to_sym
-      @as        = options[:as]   || field
-      @from      = options[:from] || field
+      @as        = options[:as]   || @field
+      @from      = options[:from] || @field
       @value     = options[:value]
       @only      = options[:only]
       @unless    = options[:unless]

data/lib/ruby_serializer.rb

@@ -2,16 +2,17 @@ module RubySerializer
 
   #------------------------------------------------------------------------------------------------
 
-  VERSION     = '0.0.1'
+  VERSION     = '1.0.0'
   SUMMARY     = 'Serialize POROs to JSON'
   DESCRIPTION = 'A general purpose library for serializing plain old ruby objects (POROs) into JSON using a declarative DSL'
   LIB         = File.dirname(__FILE__)
 
   #------------------------------------------------------------------------------------------------
 
-  autoload :Dsl,   File.join(LIB, 'ruby_serializer/dsl')
-  autoload :Base,  File.join(LIB, 'ruby_serializer/base')
-  autoload :Field, File.join(LIB, 'ruby_serializer/field')
+  autoload :Dsl,         File.join(LIB, 'ruby_serializer/dsl')
+  autoload :Base,        File.join(LIB, 'ruby_serializer/base')
+  autoload :Field,       File.join(LIB, 'ruby_serializer/field')
+  autoload :Association, File.join(LIB ,'ruby_serializer/association')
 
   #------------------------------------------------------------------------------------------------
 

data/readme.md

@@ -6,7 +6,7 @@ into JSON using a declarative DSL.
 ## Installation
 
 ```bash
-    $ gem install ruby-serializer      # ... or add to your Gemfile as appropriate
+  $ gem install ruby-serializer      # ... or add to your Gemfile as appropriate
 ```
 
 ## Usage
@@ -38,6 +38,21 @@ And serialize using...
   # { size: 'large', color: 'red', shape: 'square' }
 ```
 
+### Serializer naming convention
+
+By default, `ruby-serializer` will look for a serializer with the following naming convention 
+
+```ruby
+  "#{resource.class.name}Serializer"
+```
+
+But you can always specify the serializer class explicitly:
+
+```ruby
+  shape = Shape.new(...)
+  json  = RubySerializer.as_json shape, with: MyCustomSerializer
+```
+
 ## Beyond the basics
 
 Ok, that was very basic, but with RubySerializer you can also:
@@ -50,54 +65,153 @@ Ok, that was very basic, but with RubySerializer you can also:
   * `:include` nested `:belongs_to` associated models
   * `:include` nested `:has_one` associated models
   * `:include` nested `:has_many` associated models
-  * serialize an array of models
-  * add `ActionController` integration for easy API serialization
 
 ### Exposing attributes with another name
 
->> _TODO_
+You can expose an attribute with a different name using `:as`
+
+```ruby
+  class UserSerializer < RubySerializer::Base
+    expose :id
+    expose :name,  as: :user_name
+    expose :email, as: :user_email
+  end
+
+  user = User.new(id: 42, name: 'Jake', email: 'jake@codeincomplete.com')
+  json = RubySerializer.as_json user
+
+  # { id: 42, user_name: 'Jake', user_email: 'jake@codeincomplete.com' }
+```
 
 ### Exposing attributes with custom values
 
->> _TODO_
+You can expose an attribute with a different value using `:value`
+
+```ruby
+  class UserSerializer < RubySerializer::Base
+    expose :id
+    expose :static,  value: 'static'                      # expose a static attribute
+    expose :dynamic, value: -> { resource.name.reverse }  # expose a dynamic attribute using a lambda
+    expose :method,  value: :name                         # expose a dynamic attribute using a symbol (calls a method on the underlying resource automatically)
+  end
+
+  user = User.new(id: 42, name: 'Jake')
+  json = RubySerializer.as_json user
+
+  # { id: 42, static: 'static', dynamic: 'ekaJ', method: 'Jake' }
+```
 
 ### Exposing attributes conditionally
 
->> _TODO_
+You can expose attributes conditionally using `:only` and `:unless`
+
+```ruby
+  class UserSerializer < RubySerializer::Base
+    expose :id
+    expose :admin,  only: :admin?                             # expose this field only when resource.admin?
+    expose :name,   only:   -> { resource.name.present? }     # expose this field only when resource.name.present?
+    expose :email,  unless: -> { resource.email.blank?  }     # expose this field unless resource.email.blank?
+  end
+
+  user = User.new(id: 1)
+  json = RubySerializer.as_json user
+
+  # { id: 1 } 
+
+  user = User.new(id: 2, name: 'Joe')
+  json = RubySerializer.as_json user
+
+  # { id: 2, name: 'Joe' }
+
+  user = User.new(id: 3, name: 'Bob', admin: true)
+  json = RubySerializer.as_json user
+
+  # { id: 3, name: 'Bob', admin: true }
+
+```
 
 ### Exposing attributes within a namespace
 
->> _TODO_
+You can nest serialized attributes using a `:namespace`:
 
-### Exposing model validation errors
+```ruby
+  class UserSerializer < RubySerializer::Base
+    expose :id
+    namespace :i18n do
+      expose :locale
+      expose :time_zone
+    end
+  end
+
+  user = User.new(id: 42, locale: 'en-us', time_zone: 'UTC')
+  json = RubySerializer.as_json user
 
->> _TODO_
+  # { id: 42, i18n: { locale: 'en-us', time_zone: 'UTC' } }
+```
 
 ### Exposing associations
 
->> _TODO_
+If your models have ActiveRecord like associations you can declare them in your serializers and
+then use the optional `:include` mechanism to choose when to include them as nested resources
+during serialization:
+
+```ruby
+  class Publisher
+    attr :id, :name
+    has_many :books
+  end
+
+  class Book
+    attr :isbn, :name
+    belongs_to :publisher
+  end
+
+  class PublisherSerializer
+    expose :id
+    expose :name
+    has_many :books
+  end
+
+  class BookSerializer
+    expose :isbn
+    expose :name
+    belongs_to :publisher
+  end
+
+  publisher = Publisher.new(id: 42, name: 'Addison Wesley')
+
+  RubySerializer.as_json publisher                     # WITHOUT :include
+
+  # { id: 42, name: 'Addison Wesley' }
+
+  RubySerializer.as_json publisher, include: :books    # WITH :include
 
-### Serializing arrays
+  # { id: 42, name: 'Addison Wesley', books: [
+  #   { isbn: '020161622X', name: 'Pragmatic Programmer' },
+  #   { isbn: '0201633612', name: 'Design Patterns '},
+  #   ...
+  # ] }
+```
 
->> _TODO_
+`ruby-serializer` supports `belongs_to`, `has_one`, and `has_many` associations.
 
-### ActionController integration
+You can include multiple associations using an array of includes:
 
->> _TODO_
+```ruby
+  RubySerializer.as_json publisher, include: [ :books, :address, :websites ]
+```
 
-# TODO
+You can also include nested associations:
 
-  * :belongs_to
-  * :has_one
-  * :has_many
-  * :includes
-  * ActionController integration
-  * documentation
+```ruby
+  RubySerializer.as_json publisher, include: { books: [ :authors ] }
+```
+
+### Exposing model validation errors
 
-# Roadmap
+By default, if your underlying model responds to `:valid?` and returns `false` then the
+serialized response will automatically include a serialized `:errors` attribute.
 
-  * Extensibility with custom Field types
- 
 # License
 
 See [LICENSE](https://github.com/jakesgordon/ruby-serializer/blob/master/LICENSE) file.

data/test/association_test.rb

@@ -0,0 +1,288 @@
+require_relative 'test_case'
+
+module RubySerializer
+  class AssociationTest < TestCase
+
+    #----------------------------------------------------------------------------------------------
+
+    PORTLAND = { id: :portland, city: 'Portland',      state: 'OR' }
+    SEATTLE  = { id: :seattle,  city: 'Seattle',       state: 'WA' }
+    BOSTON   = { id: :boston,   city: 'Boston',        state: 'MA' }
+    NYC      = { id: :nyc,      city: 'New York',      state: 'NY' }
+    SF       = { id: :sf,       city: 'San Francisco', state: 'CA' }
+    LA       = { id: :la,       city: 'Los Angeles',   state: 'LA' }
+    CHICAGO  = { id: :chicago,  city: 'Chicago',       state: 'IL' }
+    DALLAS   = { id: :dallas,   city: 'Dallas',        state: 'TX' }
+    REDMOND  = { id: :redmond,  city: 'Redmond',       state: 'WA' }
+
+    MCCONNEL  = { id: :mcconnel,  name: 'Steve McConnel', address: SEATTLE  }
+    HUNT      = { id: :hunt,      name: 'Andrew Hunt',    address: PORTLAND }
+    THOMAS    = { id: :thomas,    name: 'David Thomas',   address: BOSTON   }
+    GAMMA     = { id: :gamma,     name: 'Erich Gamma',    address: NYC      }
+    HELM      = { id: :helm,      name: 'Richard Helm',   address: SF       }
+    JOHNSON   = { id: :johnson,   name: 'Ralph Johnson',  address: CHICAGO  }
+    VLISSIDES = { id: :vlissides, name: 'John Vlissides', address: DALLAS   }
+
+    PP = { id: :pp, isbn: '020161622X', name: 'Pragmatic Programmer', publisher_id: :aw, authors: [ HUNT, THOMAS ] }
+    DP = { id: :dp, isbn: '0201633612', name: 'Design Patterns',      publisher_id: :aw, authors: [ GAMMA, HELM, JOHNSON, VLISSIDES ] }
+    CC = { id: :cc, isbn: '0735619670', name: 'Code Complete',        publisher_id: :ms, authors: [ MCCONNEL ] }
+
+    AW = { id: :aw, name: 'Addison-Wesley',  address: LA,      books: [ PP, DP ]  }
+    MS = { id: :ms, name: 'Microsoft Press', address: REDMOND, books: [ CC ]      }
+
+    PROGRAMMING = { id: :programming, name: 'Programming', books: [ PP, DP, CC ] }
+
+    #----------------------------------------------------------------------------------------------
+
+    class Publisher < Model
+      attr :id, :name
+      has_one  :address
+      has_many :books
+    end
+
+    class Book < Model
+      attr :isbn, :name
+      belongs_to :publisher
+      has_many :authors
+    end
+
+    class Author < Model
+      attr :id, :name
+      has_one :address
+    end
+
+    class Address < Model
+      attr :id, :city, :state
+    end
+
+    class Category < Model
+      attr :id, :name
+      has_many :books
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class PublisherSerializer < RubySerializer::Base
+      expose   :id
+      expose   :name
+      has_one  :address
+      has_many :books
+    end
+
+    class BookSerializer < RubySerializer::Base
+      expose     :isbn
+      expose     :name
+      belongs_to :publisher
+      has_many   :authors
+    end
+
+    class AuthorSerializer < RubySerializer::Base
+      expose   :id
+      expose   :name
+      has_one  :address
+    end
+
+    class AddressSerializer < RubySerializer::Base
+      expose :id
+      expose :city
+      expose :state
+    end
+
+    class CategorySerializer < RubySerializer::Base
+      expose   :id
+      expose   :name
+      has_many :books
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_belongs_to
+
+      book    = books(PP)
+      with    = serialize book, include: :publisher
+      without = serialize book
+
+      assert_book      PP, with, with: :publisher
+      assert_publisher AW, with[:publisher]
+      assert_book      PP, without
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_has_one
+
+      author  = authors(HUNT)
+      with    = serialize author, include: :address
+      without = serialize author
+
+      assert_author  HUNT,     with, with: :address
+      assert_address PORTLAND, with[:address]
+      assert_author  HUNT,     without
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_has_many
+
+      publisher = publishers(AW)
+      with      = serialize publisher, include: :books
+      without   = serialize publisher
+
+      assert_publisher AW, with, with: :books
+      assert_equal     2,  with[:books].length
+      assert_book      PP, with[:books][0]
+      assert_book      DP, with[:books][1]
+      assert_publisher AW, without
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_multiple_includes
+      variations = [
+        [ :books, :address   ],   # verify using array of symbols
+        [ 'books', 'address' ],   # verify using array of strings
+          "books,address",        # verify using a comma separated string
+          "  books , address "    # verify using a comma separated string (with whitespace)
+      ]
+      variations.each do |includes|
+        publisher = publishers(AW)
+        json      = serialize publisher, include: includes
+        assert_publisher AW, json, with: [ :address, :books ]
+        assert_address   LA, json[:address]
+        assert_equal     2,  json[:books].length
+        assert_book      PP, json[:books][0]
+        assert_book      DP, json[:books][1]
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_nested_includes
+      publisher = publishers(AW)
+      json      = serialize publisher, include: "books.authors.address"
+      assert_publisher AW,        json, with: :books
+      assert_equal     2,         json[:books].length
+      assert_book      PP,        json[:books][0], with: :authors
+      assert_equal     2,         json[:books][0][:authors].length
+      assert_author    HUNT,      json[:books][0][:authors][0],            with: :address
+      assert_address   PORTLAND,  json[:books][0][:authors][0][:address]
+      assert_author    THOMAS,    json[:books][0][:authors][1],            with: :address
+      assert_address   BOSTON,    json[:books][0][:authors][1][:address]
+      assert_book      DP,        json[:books][1],                         with: :authors
+      assert_equal     4,         json[:books][1][:authors].length
+      assert_author    GAMMA,     json[:books][1][:authors][0],            with: :address
+      assert_address   NYC,       json[:books][1][:authors][0][:address]
+      assert_author    HELM,      json[:books][1][:authors][1],            with: :address
+      assert_address   SF,        json[:books][1][:authors][1][:address]
+      assert_author    JOHNSON,   json[:books][1][:authors][2],            with: :address
+      assert_address   CHICAGO,   json[:books][1][:authors][2][:address]
+      assert_author    VLISSIDES, json[:books][1][:authors][3],            with: :address
+      assert_address   DALLAS,    json[:books][1][:authors][3][:address]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_multiple_nested_includes
+      category = categories(PROGRAMMING)
+      json     = serialize category, include: "books.publisher, books.authors"
+      assert_category  PROGRAMMING, json, with: :books
+      assert_equal     3,           json[:books].length
+      assert_book      PP,          json[:books][0], with: [ :publisher, :authors ]
+      assert_publisher AW,          json[:books][0][:publisher]
+      assert_equal     2,           json[:books][0][:authors].length
+      assert_author    HUNT,        json[:books][0][:authors][0]
+      assert_author    THOMAS,      json[:books][0][:authors][1]
+      assert_book      DP,          json[:books][1], with: [ :publisher, :authors ]
+      assert_publisher AW,          json[:books][1][:publisher]
+      assert_equal     4,           json[:books][1][:authors].length
+      assert_author    GAMMA,       json[:books][1][:authors][0]
+      assert_author    HELM,        json[:books][1][:authors][1]
+      assert_author    JOHNSON,     json[:books][1][:authors][2]
+      assert_author    VLISSIDES,   json[:books][1][:authors][3]
+      assert_book      CC,          json[:books][2], with: [ :publisher, :authors ]
+      assert_publisher MS,          json[:books][2][:publisher]
+      assert_equal     1,           json[:books][2][:authors].length
+      assert_author    MCCONNEL,    json[:books][2][:authors][0]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    private
+
+    def addresses(fixture)
+      Address.new(fixture)
+    end
+
+    def authors(fixture)
+      author = Author.new(fixture)
+      author.address = addresses(fixture[:address]) if fixture.key?(:address)
+      author
+    end
+
+    def books(fixture)
+      book = Book.new(fixture)
+      book.publisher = publishers(fixture[:publisher_id], false)
+      book.authors   = Array(fixture[:authors]).map { |a| authors(a) } if fixture.key?(:authors)
+      book
+    end
+
+    def publishers(fixture, include_books = true)
+      fixture = AW if fixture == :aw
+      fixture = MS if fixture == :ms
+      publisher = Publisher.new(fixture)
+      publisher.address = addresses(fixture[:address]) if fixture.key?(:address)
+      publisher.books = Array(fixture[:books]).map { |b| books(b) } if include_books && fixture[:books]
+      publisher
+    end
+
+    def categories(fixture)
+      category = Category.new(fixture)
+      category.books = Array(fixture[:books]).map { |b| books(b) } if fixture.key?(:books)
+      category
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def assert_publisher(expected, actual, options = {})
+      expected_keys = [ :id, :name ] + Array(options[:with])
+      assert_set   expected_keys,   actual.keys
+      assert_equal expected[:id],   actual[:id]
+      assert_equal expected[:name], actual[:name]
+    end
+
+    def assert_book(expected, actual, options = {})
+      expected_keys = [ :isbn, :name, :publisher_id ] + Array(options[:with])
+      assert_set   expected_keys,           actual.keys
+      assert_equal expected[:isbn],         actual[:isbn]
+      assert_equal expected[:name],         actual[:name]
+      assert_equal expected[:publisher_id], actual[:publisher_id]
+    end
+
+    def assert_author(expected, actual, options = {})
+      expected_keys = [ :id, :name ] + Array(options[:with])
+      assert_set   expected_keys,   actual.keys
+      assert_equal expected[:id],   actual[:id]
+      assert_equal expected[:name], actual[:name]
+    end
+
+    def assert_address(expected, actual)
+      assert_set   [ :id, :city, :state ], actual.keys
+      assert_equal expected[:id],          actual[:id]
+      assert_equal expected[:city],        actual[:city]
+      assert_equal expected[:state],       actual[:state]
+    end
+
+    def assert_category(expected, actual, options = {})
+      expected_keys = [ :id, :name ] + Array(options[:with])
+      assert_equal expected_keys,   actual.keys
+      assert_equal expected[:id],   actual[:id]
+      assert_equal expected[:name], actual[:name]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/test/basic_test.rb

@@ -6,15 +6,20 @@ module RubySerializer
     #----------------------------------------------------------------------------------------------
 
     def test_gem_information
-      assert_equal '0.0.1',                         VERSION
+      assert_equal '1.0.0',                         VERSION
       assert_equal 'Serialize POROs to JSON',       SUMMARY
       assert_match 'A general purpose library for', DESCRIPTION
     end
 
     #----------------------------------------------------------------------------------------------
 
-    Shape = Struct.new(:color, :shape)
-    Car   = Struct.new(:make, :model)
+    class Shape < Model
+      attr :color, :shape
+    end
+
+    class Car < Model
+      attr :make, :model
+    end
 
     class ShapeSerializer < RubySerializer::Base
       expose :color
@@ -30,12 +35,12 @@ module RubySerializer
 
     def test_basic_serialization
 
-      json = RubySerializer.as_json Shape.new(:red, :square)
+      json = serialize Shape.new(color: :red, shape: :square)
       assert_set   [ :color, :shape ], json.keys
       assert_equal :red,               json[:color]
       assert_equal :square,            json[:shape]
 
-      json = RubySerializer.as_json Car.new(:honda, :civic)
+      json = serialize Car.new(make: :honda, model: :civic)
       assert_set   [ :make, :model ], json.keys
       assert_equal :honda,            json[:make]
       assert_equal :civic,            json[:model]
@@ -46,12 +51,12 @@ module RubySerializer
 
     def test_array_serialization
       resources = [
-        Shape.new(:red,  :square),
-        Shape.new(:blue, :circle),
-        Car.new(:honda, :civic),
-        Car.new(:jeep, :wrangler)
+        Shape.new(color: :red,  shape: :square),
+        Shape.new(color: :blue, shape: :circle),
+        Car.new(make: :honda, model: :civic),
+        Car.new(make: :jeep,  model: :wrangler)
       ]
-      json = RubySerializer.as_json resources
+      json = serialize resources
       assert_equal resources.length, json.length
       assert_set   [ :color, :shape ], json[0].keys
       assert_equal :red,               json[0][:color]
@@ -70,7 +75,7 @@ module RubySerializer
     #----------------------------------------------------------------------------------------------
 
     def test_serialize_with_root
-      json = RubySerializer.as_json Car.new(:honda, :civic), root: :car
+      json = serialize Car.new(make: :honda, model: :civic), root: :car
       assert_set [ :car ], json.keys
       assert_equal :honda, json[:car][:make]
       assert_equal :civic, json[:car][:model]
@@ -79,8 +84,8 @@ module RubySerializer
     #----------------------------------------------------------------------------------------------
 
     def test_serialize_with_errors
-      resource = OpenStruct.new(color: :red, shape: :sausages, valid?: false, errors: { shape: 'is invalid' })
-      json     = RubySerializer.as_json resource, with: ShapeSerializer
+      resource = Shape.new(color: :red, shape: :sausages, valid: false, errors: { shape: 'is invalid' })
+      json     = serialize resource, with: ShapeSerializer
       expected = [ :color, :shape, :errors ]
       assert_set expected,       json.keys
       assert_equal :red,         json[:color]

data/test/expose_test.rb

@@ -10,7 +10,14 @@ module RubySerializer
     EMAIL  = 'Email'
     SECRET = 'Secret'
 
-    Resource = OpenStruct
+    class Resource < Model
+      attr :id
+      attr :name
+      attr :email
+      attr :secret  # this attribute will not be exposed in any serializer
+      attr :value   # this attribute might be used as a custom :value in some serializers
+      attr :show    # this attribute might be used to conditionally show :only or :unless
+    end
 
     #==============================================================================================
     # Sample Serializers
@@ -45,9 +52,8 @@ module RubySerializer
     class CustomValueSerializer < RubySerializer::Base
       expose :id
       expose :static,  value: 'static value'
-      expose :method,  value: :method_value
       expose :dynamic, value: -> { "dynamic value (#{resource.name})" }
-      expose :empty,   value: nil
+      expose :method,  value: :value
     end
 
     #----------------------------------------------------------------------------------------------
@@ -89,7 +95,7 @@ module RubySerializer
 
     def test_expose_attributes_unchanged
       resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
-      json     = RubySerializer.as_json resource, with: BasicSerializer
+      json     = serialize resource, with: BasicSerializer
       expected = [ :id, :name, :email ]
       assert_set   expected, json.keys
       assert_equal ID,       json[:id]
@@ -101,7 +107,7 @@ module RubySerializer
 
     def test_expose_renamed_attributes
       resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
-      json     = RubySerializer.as_json resource, with: RenamingSerializer
+      json     = serialize resource, with: RenamingSerializer
       expected = [ :id, :user_name, :user_email ]
       assert_set   expected, json.keys
       assert_equal ID,       json[:id]
@@ -113,7 +119,7 @@ module RubySerializer
 
     def test_expose_namespaced_attributes
       resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
-      json     = RubySerializer.as_json resource, with: NamespaceSerializer
+      json     = serialize resource, with: NamespaceSerializer
       expected = [ :id, :user ]
       assert_set   expected,          json.keys
       assert_equal ID,                json[:id]
@@ -125,23 +131,22 @@ module RubySerializer
     #----------------------------------------------------------------------------------------------
 
     def test_expose_attributes_with_custom_values
-      resource = Resource.new(id: ID, name: NAME, method_value: 'method value')
-      json     = RubySerializer.as_json resource, with: CustomValueSerializer
-      expected = [ :id, :static, :dynamic, :method, :empty ]
+      resource = Resource.new(id: ID, name: NAME, value: 'method value')
+      json     = serialize resource, with: CustomValueSerializer
+      expected = [ :id, :static, :dynamic, :method ]
       assert_set   expected,               json.keys
       assert_equal ID,                     json[:id]
       assert_equal 'static value',         json[:static]
       assert_equal 'dynamic value (Name)', json[:dynamic]
       assert_equal 'method value',         json[:method]
-      assert_equal nil,                    json[:empty]
     end
 
     #----------------------------------------------------------------------------------------------
 
     def test_expose_attributes_conditionally
-      show        = RubySerializer.as_json Resource.new(id: ID, show: true),  with: ConditionalSerializer
-      noshow      = RubySerializer.as_json Resource.new(id: ID, show: false), with: ConditionalSerializer
-      unspecified = RubySerializer.as_json Resource.new(id: ID),              with: ConditionalSerializer
+      show        = serialize Resource.new(id: ID, show: true),  with: ConditionalSerializer
+      noshow      = serialize Resource.new(id: ID, show: false), with: ConditionalSerializer
+      unspecified = serialize Resource.new(id: ID),              with: ConditionalSerializer
       assert_set [ :id, :only_true, :unless_false, :only_method,   :only_dynamic   ], show.keys
       assert_set [ :id, :only_true, :unless_false, :unless_method, :unless_dynamic ], noshow.keys
       assert_set [ :id, :only_true, :unless_false, :unless_method, :unless_dynamic ], unspecified.keys
@@ -152,7 +157,7 @@ module RubySerializer
     def test_expose_attributes_using_custom_resource_name
 
       resource = Resource.new(id: ID, value: 42, show: false)
-      json     = RubySerializer.as_json resource, with: CustomResourceNameSerializer
+      json     = serialize resource, with: CustomResourceNameSerializer
       expected = [ :id, :value, :show_unless ]
       assert_set   expected,      json.keys
       assert_equal ID,            json[:id]
@@ -160,7 +165,7 @@ module RubySerializer
       assert_equal "show unless", json[:show_unless]
 
       resource = Resource.new(id: ID, value: 99, show: true)
-      json     = RubySerializer.as_json resource, with: CustomResourceNameSerializer
+      json     = serialize resource, with: CustomResourceNameSerializer
       expected = [ :id, :value, :show_only ]
       assert_set   expected,      json.keys
       assert_equal ID,            json[:id]
@@ -175,14 +180,14 @@ module RubySerializer
 
       resource = Resource.new(id: ID)
 
-      json     = RubySerializer.as_json resource, value: 42, show: false, with: CustomOptionsSerializer
+      json     = serialize resource, value: 42, show: false, with: CustomOptionsSerializer
       expected = [ :id, :value, :show_unless ]
       assert_set   expected,      json.keys
       assert_equal ID,            json[:id]
       assert_equal "value is 42", json[:value]
       assert_equal "show unless", json[:show_unless]
 
-      json     = RubySerializer.as_json resource, value: 99, show: true, with: CustomOptionsSerializer
+      json     = serialize resource, value: 99, show: true, with: CustomOptionsSerializer
       expected = [ :id, :value, :show_only ]
       assert_set   expected,      json.keys
       assert_equal ID,            json[:id]

data/test/model.rb

@@ -0,0 +1,66 @@
+module RubySerializer
+  class Model   # simple model with ActiveRecord like associations
+
+    def initialize(attributes = {})
+      @valid  = true
+      @errors = []
+      attributes.each do |key, value|
+        instance_variable_set "@#{key}", value
+      end
+    end
+
+    def valid?
+      @valid
+    end
+
+    def errors
+      @errors
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def self.belongs_to(key)
+      idkey     = "#{key}_id"
+      instvar   = "@#{key}"
+      idinstvar = "@#{idkey}"
+      define_method key do
+        instance_variable_get instvar
+      end
+      define_method idkey do
+        instance_variable_get idinstvar
+      end
+      define_method "#{key}=" do |value|
+        instance_variable_set instvar,   value
+        instance_variable_set idinstvar, value ? value.id : nil
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def self.has_one(key)
+      instvar = "@#{key}"
+      define_method key do
+        instance_variable_get instvar
+      end
+      define_method "#{key}=" do |value|
+        instance_variable_set instvar, value
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def self.has_many(key)
+      instvar = "@#{key}"
+      define_method key do
+        instance_variable_set instvar, [] unless instance_variable_defined?(instvar)
+        instance_variable_get instvar
+      end
+      define_method "#{key}=" do |value|
+        instance_variable_set instvar, Array(value)
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/test/test_case.rb

@@ -2,13 +2,22 @@ require_relative '../lib/ruby_serializer'
 
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'ostruct'
 require 'byebug'
 
+require_relative 'model'
+
 module RubySerializer
   class TestCase < Minitest::Test
 
     #----------------------------------------------------------------------------------------------
 
+    def serialize(resource, options = {})
+      RubySerializer.as_json resource, options
+    end
+
+    #----------------------------------------------------------------------------------------------
+
     def assert_set(expected, actual, message = nil)
       assert_equal Set.new(expected), Set.new(actual), message
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-serializer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Jake Gordon
@@ -81,13 +81,16 @@ files:
 - LICENSE
 - Rakefile
 - lib/ruby_serializer.rb
+- lib/ruby_serializer/association.rb
 - lib/ruby_serializer/base.rb
 - lib/ruby_serializer/dsl.rb
 - lib/ruby_serializer/field.rb
 - readme.md
 - ruby-serializer.gemspec
+- test/association_test.rb
 - test/basic_test.rb
 - test/expose_test.rb
+- test/model.rb
 - test/test_case.rb
 homepage: https://github.com/jakesgordon/ruby-serializer
 licenses: