[MUSIC]

In this lecture, we will discuss adding geolocation coordinates to Image.

And encapsulating those geolocation coordinates using a Point class,

implemented as an ActiveRecord Value Object.

And then we'll solve an issue brought up by factoring an immutable value object,

by looking at how you can further customize FactoryGirl

to work with objects with custom constructors.

To get started adding position information to our image object,

what we need to do first is add a migration for longitude and latitude.

Taking a look at the migration, we'll note by the name that we used for

the migration, Rails knew to apply this to the images table.

And we want to leave these columns pretty much as is,

as they were defined, because they are optional.

Except we want to add an index based upon the values together, longitude and

latitude.

Let's go ahead and migrate our schema.

And it's been my experience on Windows platforms that you actually have to

explicitly migrate the test profile and not wait for the test.

So now if we peek in at the database, take a look at images.

We'll notice that we have two new columns of database type double precision

that are not required, and we also have our index ready to go.

And we'll notice with just that migration, when we run our spec

against just the properties context, that all tests are now passing.

That is because our first set of tests just verified that the image does

have longitude and latitude, and can be saved with them being empty.

Our second test verifies that our image factory can create an instance of

the image given these additional parameters.

And that after it is created, we're able to do a query and

find that our object exists.

If we take a look at the representation of our image in db/schema,

we will notice it's a little eclectic.

Sure, lat and lng are very cohesive concepts, they go together.

But caption and image creator and any of the other properties that

would be associated with image, not all that cohesive.

So rather than dealing with lat and lng each time, I'd like to wrap these two

properties up in a containing class, so that an image has a position

represented by a point that has lat and lng instead of image has lat and lng.

And one of the first things we have to do is create our point class,

except it isn't going to be a normal class that we're used to dealing with.

It isn't going to be an active record or a mongoid class.

It's going to be a value object of active record, but it's not going to have an ID.

It's just going to represent information that's going to be part

of an official active record class.

Now I don't know of any templates that create value object class, so

we're going to have to do this manually.

And when you create it manually, make sure that you name your file correctly.

Make sure that everything is in snake case,

whereas in this case you only have one word.

So there are no underscores in our filename.

It's very important, do not name this with a capital p,

no matter what your editor wants to let you do.

Now our point class is going to be a representation of longitude and latitude.

So let's generate some setters and getters for this.

Remember it's not an active record class, so

it's not extending anything from the active record library.

We have to implement most of this ourselves.

So because it's not an active record class, we need to supply an initialize, so

that we can conveniently instantiate

instances of this object with the right properties.

And here is the case where I'm going to use, longitudes and then latitude.

In one of the suggested methods that active record has for

value object classes is to determine equality.

So what I'm saying here, is if the right hand side is nil, return false,

otherwise return the result of comparing their longitude to our longitude,

their latitude to our latitude.

And there are many cases where

exact value comparison is not going to be the greatest thing.

So what I'll do is I'll add a triple equals operator.

Which is anything we define it to be but we're saying that, yeah,

let's kind of consider them the same, that if we're compared against nil,

we will return false.

But if we're compared against something that does exist, we will return

the comparison of two rounded values down to two decimal places.

That's kind of in the neighborhood.

And I would like to add two accessor methods that will report

properties together.

And let me be explicit, I'm going to define one to be longitude latitude and

the other one latitude longitude and they return an array.

Because an array is one of the common representations of a geographic

coordinate.

And then one of the prefered representations in my mind, is a hash, but

will represent the individual values explicitly keyed inside the hash.

So at this point we have our image having the longitude and latitude properties,

and we have a point value object class constructed so

that it can represent longitude and latitude.

Now, what we need is the image to be composed of that value object class.

But if we look at our test,

the reason that's initially failing is because we're making

reference to a factory that does not exist yet, we want to be able to build a point.

If you are looking in your repository,

you'll actually find a copy of this already.

I am just going to re-author it little bit at a time and show you how it was built.

I going to start by putting all of my value objects representing locations in

factories location.

I'm going to put the couple of different types of factories, and

of course start it with a factory for point.

But you'll notice that when we just use that default definition,

it's coming up with this error of, wrong number of arguments,

(0 for 2), and that doesn't change even if we put values in here.

Because the default model for FactoryGirl is to call a default

constructor of an object and then inject properties in calling setters.

This is a value object.

Value objects are immutable and we'd like to model our class

to be consistent with that view of the world that active record has.

So we need to have FactoryGirl not call the default constructor but

to call a constructor that passes the values we want to have.

So instead of listing them out in a normal location, we create this transient block.

This will give us a placeholder of where we can pass these arguments, and

then define initialize_with.

And here's where we get a chance to call the constructor and

use the values that are in this transient block.

Now at least FactoryGirl is happy with our definition of the factory.

Let's improve a slight amount.

Instead of hard coding every lat and log to be 1 and 2,

why don't we dynamically make each one different and

put it somewhere within the area of the Baltimore inner harbor.

Somewhere in the Baltimore vicinity.

And for the cases where we want a specific target, let's go ahead and

define a trait of JHU, Johns Hopkins University, and

supply a specific value for the lat and the lng.

So our factory was good enough with the hard coded 1 and 2.

But now what we need to realize is, what's going on here with this position=?

Image doesn't have the concept of a position.

What we're going to do is assign a point to this position, so let's go take a look.

And what we're going to do is to find an active record composition property

called position, that we are going to get and set things of this type.

But of course if we say nothing, it's going to default the property of

symbol position to mean class position.

Where our class is called a point.

So we need to specify what our value object class name is.

All right, now that he knows the type of the object that we want to pass in.

But now we have this error of no method position for point.

What this is obscurely trying to say is,

active record by default doesn't know how to apply a point to a position property.

So what it's going to do is ask the point, give me your position, and

then I'll go from there.

And point saying, I don't have that method.

And how we can fix that is we define a mapping that goes from point

longitude property to images longitude column, and

its latitude property to the latitude column.

Okay with that changed, our test surpassing.

And then I also want to make this clear, that this is an optional property.

And that if I did not supply position when I called the factory,

I want to have a default location added rather than nils.

So you notice here I'm building my point,

taking advantage of the factory we just created.

And calling to_hash instead of attributes_for,

we end up with the same result, a hash of properties for

that object, except attributes_for tries to call the default initializer and

as we saw with a value object, we have no default initializer.

We need to call something like build in order to instantiate it with the custom

constructor.

And so now when we create images, we get a lng and a lat for it's positioned.

We build image instance, we will also get those random properties.

All right now that we have image longitude and latitude in position expressed

inside of our image in our model, I went ahead and updated our rake file.

We already had the expressions of those values in the rake file,

now I'm actually doing something with them.

So now when you do a reset all, you're not only getting the metadata, the images,

now you're getting the geolocation information added for each of the images.

Okay, I want to take a moment and highlight this notion of a value object.

Let's grab the sample image, it happens to be the front of the B&O Railroad Museum,

and you notice it's lng is -76 degrees and lat 39 degrees,

as shown by this normal accessor method.

We can also get that information by getting its position.

We notice a point object comes out that has the exact same values and

we can call its getter as well.

So if I assign my position to a variable,

what would you expect to see if I say lng=1?

If I print the value of the value object, it says it's 1.

If I print the value of the image, it says it's -76 degrees.

If I print the value of the lng from the position generated by the image,

it says it's 1.

That's kind of odd but, that's the way it works.

Now the fact that when we change the position it didn't change the image,

that's not surprising when we talk about these as being non-modifiable.

Changing the position does not change the position of the image.

The fact that when we go back to the image and ask for a new position,

that we get the old one each time is a little surprising to me, but

here's how we change.

So if we say, image.position=pos object and

now check the longitude, it is now 1.0.

So the way you change the value is you assign the entire value object

to the property of the model object.

You can't do it a property at a time, you must do it a value object at a time.

And one thing also to notice, let's go ahead and

assign the image to this new point of 3,4, so the image has 3,4.

And then let me just try to change the value of the point that we passed in.

And Rails is stopping you, saying that this value object is frozen,

it's assigned to our image and you should not be changing it.

Now when I defined this class, I defined setters on it.

And I probably shouldn't,

I should have probably did getters just to be certain of it.

But just to drive home the point that these objects are not meant to

be modified.

They're meant to be instantiated and they're meant to pass in the values in

bulk and not be modified anywhere down the road.

In summary, the expressed geolocation coordinates as a position

within Image using the Point class.

And this demonstrated the difference between a model and a value object class.

Where a model, like an image, has a primary key and it's mutable.

We can change the images caption.

Where as a value object, like a point, has no identity it just as values, and

ideally it's immutable.

We need to go back to the image if we want to change the lat and the lng.

But we can do so by giving it a fresh point.

You can find more information in the docs available under ActiveRecord,

Aggregations, ClassMethods.

And then we solved an issue with FactoryGirl,

with the value object having a custom constructor.

And showed how you could create an immutable object

that required everything to be passed in the constructor area.

What's next?

Geolocation Queries with Geokit Rails.

Let's leverage this representation of longitude and latitude and

implement a set of queries that could give us information about distances.

DB: Image Position and Value Objects

Capstone: Photo Tourist Web Application

Conoce a los instructores