rename to_object to to_struct

Author: elShiaLabeouf

README.md

@@ -139,7 +139,7 @@ To use a specific format, include the corresponding module in your representer a
 - `Representable::JSON#to_json`
 - `Representable::JSON#to_hash` (provides a hash instead of string)
 - `Representable::Hash#to_hash`
-- `Representable::Object#to_object` (provides a Struct-based object)
+- `Representable::Struct#to_struct` (provides a Struct-based object)
 - `Representable::XML#to_xml`
 - `Representable::YAML#to_yaml`
 

lib/representable/hash.rb

@@ -35,6 +35,7 @@ def from_hash(data, options={}, binding_builder=Binding)
 
     def to_hash(options={}, binding_builder=Binding)
       hash = create_representation_with({}, options, binding_builder)
+
       return hash if options[:wrap] == false
       return hash unless (wrap = options[:wrap] || representation_wrap(options))
 

lib/representable/object.rb

@@ -3,8 +3,6 @@
 
 module Representable
   module Object
-    autoload :Collection, 'representable/object/collection'
-
     def self.included(base)
       base.class_eval do
         include Representable
@@ -15,40 +13,17 @@ def self.included(base)
 
 
     module ClassMethods
-      def format_engine
-        Representable::Object
-      end
-
       def collection_representer_class
         Collection
       end
-
-      def cache_struct
-        @represented_struct ||= Struct.new(*representable_attrs.keys.map(&:to_sym))
-      end
-
-      def cache_wrapper_struct(wrap:)
-        struct_name = :"@_wrapper_struct_#{wrap}"
-        return instance_variable_get(struct_name) if instance_variable_defined?(struct_name)
-
-        instance_variable_set(struct_name, Struct.new(wrap))
-      end
     end
 
     def from_object(data, options={}, binding_builder=Binding)
       update_properties_from(data, options, binding_builder)
     end
 
     def to_object(options={}, binding_builder=Binding)
-      represented_struct = self.class.cache_struct
-
-      object = create_representation_with(represented_struct.new, options, binding_builder)
-      return object if options[:wrap] == false
-      return object unless (wrap = options[:wrap] || representation_wrap(options))
-
-      wrapper_struct = self.class.cache_wrapper_struct(wrap: wrap.to_sym)
-      wrapper_struct.new(object)
+      create_representation_with(nil, options, binding_builder)
     end
-
   end
 end

lib/representable/object/binding.rb

@@ -9,16 +9,16 @@ def self.build_for(definition)  # TODO: remove default arg.
         new(definition)
       end
 
-      def read(struct, as)
-        fragment = struct.send(as) # :getter? no, that's for parsing!
+      def read(hash, as)
+        fragment = hash.send(as) # :getter? no, that's for parsing!
 
         return FragmentNotFound if fragment.nil? and typed?
 
         fragment
       end
 
-      def write(struct, fragment, as)
-        struct.send("#{as}=", fragment)
+      def write(hash, fragment, as)
+        true
       end
 
       def deserialize_method

lib/representable/struct.rb

@@ -0,0 +1,49 @@
+require 'representable'
+require 'representable/struct/binding'
+
+module Representable
+  module Struct
+    autoload :Collection, 'representable/struct/collection'
+
+    def self.included(base)
+      base.class_eval do
+        include Representable
+        extend ClassMethods
+        register_feature Representable::Struct
+      end
+    end
+
+
+    module ClassMethods
+      def format_engine
+        Representable::Struct
+      end
+
+      def collection_representer_class
+        Collection
+      end
+
+      def cache_struct
+        @represented_struct ||= ::Struct.new(*representable_attrs.keys.map(&:to_sym))
+      end
+
+      def cache_wrapper_struct(wrap:)
+        struct_name = :"@_wrapper_struct_#{wrap}"
+        return instance_variable_get(struct_name) if instance_variable_defined?(struct_name)
+
+        instance_variable_set(struct_name, ::Struct.new(wrap))
+      end
+    end
+
+    def to_struct(options={}, binding_builder=Binding)
+      represented_struct = self.class.cache_struct
+
+      object = create_representation_with(represented_struct.new, options, binding_builder)
+      return object if options[:wrap] == false
+      return object unless (wrap = options[:wrap] || representation_wrap(options))
+
+      wrapper_struct = self.class.cache_wrapper_struct(wrap: wrap.to_sym)
+      wrapper_struct.new(object)
+    end
+  end
+end

lib/representable/struct/binding.rb

@@ -0,0 +1,33 @@
+require 'representable/binding'
+
+module Representable
+  module Struct
+    class Binding < Representable::Binding
+      def self.build_for(definition)
+        return Collection.new(definition)  if definition.array?
+
+        new(definition)
+      end
+
+      def read(struct, as)
+        fragment = struct.send(as) # :getter? no, that's for parsing!
+
+        return FragmentNotFound if fragment.nil? and typed?
+
+        fragment
+      end
+
+      def write(struct, fragment, as)
+        struct.send("#{as}=", fragment)
+      end
+
+      def serialize_method
+        :to_struct
+      end
+
+      class Collection < self
+        include Representable::Binding::Collection
+      end
+    end
+  end
+end

lib/representable/object/collection.rb lib/representable/struct/collection.rblib/representable/object/collection.rb renamed to lib/representable/struct/collection.rb

@@ -1,12 +1,12 @@
 require 'representable/hash'
 
-module Representable::Object
+module Representable::Struct
   module Collection
-    include Representable::Object
+    include Representable::Struct
 
     def self.included(base)
       base.class_eval do
-        include Representable::Object
+        include Representable::Struct
         extend ClassMethods
         property(:_self, {:collection => true})
       end

test/examples/object.rb

@@ -5,8 +5,8 @@
 
 source = OpenStruct.new(
   name: "30 Years Live", songs: [
-  OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")
-]
+    OpenStruct.new(id: 1, title: "Dear Beloved"), OpenStruct.new(id: 2, title: "Fuck Armageddon")
+  ]
 )
 
 require "representable/object"
@@ -26,30 +26,3 @@ class AlbumRepresenter < Representable::Decorator
 target = Album.new
 
 AlbumRepresenter.new(target).from_object(source)
-
-# Representing to_object:
-
-class Animal
-  attr_accessor :name, :age, :species
-  def initialize(name, age, species)
-    @name = name
-    @age = age
-    @species = species
-  end
-end
-
-require "representable/object"
-
-class AnimalRepresenter < Representable::Decorator
-  include Representable::Object
-
-  property :name, getter: ->(represented:, **) { represented.name.upcase }
-  property :age
-end
-
-animal = Animal.new('Smokey',12,'c')
-animal_repr = AnimalRepresenter.new(animal).to_object(wrap: "wrapper")
-
-animal_array = [Animal.new('Shepard',22,'s'),Animal.new('Pickle',12,'c'),Animal.new('Rodgers',55,'e')]
-array_repr = AnimalRepresenter.for_collection.new(animal_array).to_object
-

test/examples/struct.rb

@@ -0,0 +1,27 @@
+require "representable/struct"
+
+# Representing to_struct:
+class Animal
+  attr_accessor :name, :age, :species
+  def initialize(name, age, species)
+    @name = name
+    @age = age
+    @species = species
+  end
+end
+
+class AnimalRepresenter < Representable::Decorator
+  include Representable::Struct
+
+  property :name, getter: ->(represented:, **) { represented.name.upcase }
+  property :age
+end
+
+animal = Animal.new('Smokey',12,'c')
+animal_repr = AnimalRepresenter.new(animal).to_struct(wrap: "wrapper")
+
+animal_array = [Animal.new('Shepard',22,'s'),Animal.new('Pickle',12,'c'),Animal.new('Rodgers',55,'e')]
+array_repr = AnimalRepresenter.for_collection.new(animal_array).to_struct
+
+animal_klass = Struct.new("Animal", :name, :age, :species)
+AnimalRepresenter.new(animal_klass.new("qwik", 12, "old")).to_struct(wrap: "wrapper")

test/object_test.rb

@@ -24,9 +24,9 @@ class ObjectTest < MiniTest::Spec
   it do
     representer.prepare(target).from_object(source)
 
-    assert_equal target.title, "The King Is Dead"
-    assert_equal target.album.name, "RUINER"
-    assert_equal target.album.songs[0].title, "IN VINO VERITAS II"
+    assert_equal "The King Is Dead", target.title
+    assert_equal "RUINER", target.album.name
+    assert_equal "IN VINO VERITAS II", target.album.songs[0].title
   end
 
   # ignore nested object when nil
@@ -51,90 +51,10 @@ class ObjectTest < MiniTest::Spec
       end
     end
 
-    # it do
-    #   representer.prepare(source).to_object
-    #   _(source.album.name).must_equal "Live"
-    #   _(source.album.songs[0].title).must_equal 1
-    # end
-  end
-end
-
-class ObjectPublicMethodsTest < Minitest::Spec
-  Song  = Struct.new(:title, :album)
-  Album = Struct.new(:id, :name, :songs, :free_concert_ticket_promo_code)
-  class AlbumRepresenter < Representable::Decorator
-    include Representable::Object
-    property :id
-    property :name, getter: ->(*) { name.lstrip.strip }
-    property :cover_png, getter: ->(options:, **) { options[:cover_png] }
-    collection :songs do
-      property :title, getter: ->(*) { title.upcase }
-      property :album, getter: ->(*) { album.upcase }
+    it do
+      representer.prepare(source).to_object
+      _(source.album.name).must_equal "Live"
+      _(source.album.songs[0].title).must_equal 1
     end
   end
-
-  #---
-  # to_object
-  let(:album) { Album.new(1, "  Rancid   ", [Song.new("In Vino Veritas II", "Rancid"), Song.new("The King Is Dead", "Rancid")], "S3KR3TK0D3") }
-  let(:cover_png) { "example.com/cover.png" }
-  it do
-    represented = AlbumRepresenter.new(album).to_object(cover_png: cover_png)
-    assert_equal represented.id, album.id
-    refute_equal represented.name, album.name
-    assert_equal represented.name, album.name.lstrip.strip
-    refute_equal represented.songs[0].title, album.songs[0].title
-    assert_equal represented.songs[0].title, album.songs[0].title.upcase
-
-    assert_respond_to album, :free_concert_ticket_promo_code
-    refute_respond_to represented, :free_concert_ticket_promo_code
-
-    assert_equal represented.cover_png, cover_png
-  end
-
-  it do
-    represented = AlbumRepresenter.new(album).to_object(cover_png: cover_png)
-    assert_equal represented.id, album.id
-    refute_equal represented.name, album.name
-    assert_equal represented.name, album.name.lstrip.strip
-    refute_equal represented.songs[0].title, album.songs[0].title
-    assert_equal represented.songs[0].title, album.songs[0].title.upcase
-
-    assert_respond_to album, :free_concert_ticket_promo_code
-    refute_respond_to represented, :free_concert_ticket_promo_code
-
-    assert_equal represented.cover_png, cover_png
-  end
-
-  let(:albums) do  [
-    Album.new(1, "Rancid", [Song.new("In Vino Veritas II", "Rancid"), Song.new("The King Is Dead", "Rancid")], "S3KR3TK0D3"),
-    Album.new(2, "Punk powerhouse", [Song.new("Hard Outside The Box", "Punk powerhous"), Song.new("Wonderful Noise", "Punk powerhous")], "S3KR3TK0D3"),
-    Album.new(3, "Into the Beyond", [Song.new("Rhythm of the night", "Into the Beyond"), Song.new("I'm blue", "Into the Beyond")], "S3KR3TK0D3"),
-  ]
-  end
-
-  it do
-    represented = AlbumRepresenter.for_collection.new(albums).to_object(cover_png: cover_png)
-    assert_equal represented.size, albums.size
-    assert_respond_to albums[0], :free_concert_ticket_promo_code
-    refute_respond_to represented[0], :free_concert_ticket_promo_code
-    assert_equal represented[0].cover_png, cover_png
-    assert_equal represented[0].class.object_id, represented[1].class.object_id
-  end
-
-  let(:wrapper) { "cool_album" }
-  let(:second_wrapper) { "magnificent_album" }
-  it do
-    represented_array = AlbumRepresenter.for_collection.new(albums).to_object(wrap: wrapper)
-    represented_object = AlbumRepresenter.new(album).to_object(wrap: second_wrapper)
-
-    assert_respond_to represented_array, wrapper
-
-    assert_respond_to represented_array.send(wrapper)[0], wrapper
-    first_song_title_represented = represented_array.send(wrapper)[0].send(wrapper).songs[0].title
-    first_song_title_original = albums[0].songs[0].title
-    assert_equal first_song_title_represented, first_song_title_original.upcase
-
-    assert_equal represented_array.send(wrapper)[0].class.object_id, represented_array.send(wrapper)[1].class.object_id # wrapper struct class is the same for collection
-    refute_equal represented_array.send(wrapper)[0].class.object_id, represented_object.class.object_id   # wrapper structs classes are different for different wrappers
-  end
 end