http_api_tools 0.3.0 → 0.3.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTc5ODNiODdjNjE4ZWQyZDFmNDAwZDVkZjU2MDkxZDQyOWJkYmQxMQ==
+    YzAxZTY2MTMwZGVmMjQ2NWEzZmU5MTNlMDk0N2YwMDA5MDRjZjBmYQ==
   data.tar.gz: !binary |-
-    YTdmODFmOTQ1ZjM5YWNmNDE5ODg0ZWNjOGI2NjY3NmFlNDhmYjlhNA==
+    YWVmNjdhODUzOWRmYTU1NjkzNDliZWQwNTg3MGY1NjBhNjZhMjIyNA==
 SHA512:
   metadata.gz: !binary |-
-    MDliOWFhOTViZmYwNzQ0OGM3Mzk4NTgzOGFiOWU5NjBmYTRiMmJmY2UwNTcz
-    YWNlM2EwOWM0YTMwZmRlZjZmNjZlZDlkMmI4ZmI0ODdkZTZmYzYwNjE0MDBh
-    NzAzNTM1ZGY0ZWY5MDVjODU2YTJiZDY5YWFhZjc5NjZiN2FhMjI=
+    YWI1YWY4NWQ2OWMyYzcyYTcwMTBiNjVhNjM5M2FkYzA4MmY2MDk5NDFmNzBj
+    MDJhNjIwNWZjMjFlZWFmNjljNzZkY2QyN2U3Nzc0Mzc4ZjBkNmViNjExMjRh
+    NjExMTcwMGE3NzNhMmJhYjViMTMxMjM5N2U2OTY3YzBlOGNkNjM=
   data.tar.gz: !binary |-
-    YzNkNWRlOGNiZGVjMGQ1MDEwOTcwMWQ0NTI0Y2Y5MTY5MzJlMWQxN2UxZDg2
-    YjgxMzVkNzM3MmMwZjdhZWMzNjdjZjZlOGQ4MWI0ZGQ5ZTkzNGRjMzMzNTUw
-    Nzg1NmYyNzBjZjhmZGE4NjcxMWNmZDhlZDg1NmE5MWVhNDQzODI=
+    MzY3YWRhOWJiMjU4NWY3MzY3N2MwZWE2MmU4Njk0NzczZTUzZjVhYzQ2MWMz
+    MGEzMjI1YWYwYzA1ODUxMGRjN2E0YTYxODkzNDBjMzkxZDM1YjI5Nzc3MjYy
+    MGU4ZTU4ODYwNmFhOWY3NTFkNzZiMWQ1NjZmYWU4MzEyNTEwZDg=

data/README.md

@@ -26,7 +26,7 @@ It has been written to work as a whole where the producer and client of the api
 
 ### Serialization
 There are two supported serialization formats - sideloading and nesting. Both formats maintain an identical api and
-usage pattern while serializing in different ways. While it is possible to provide both formats in an application, it's likely you'd stick to one as the general philosophy is thttp_api_tools a resource should always be represented in the same way.
+usage pattern while serializing in different ways. While it is possible to provide both formats in an application, it's likely you'd stick to one as the general philosophy is http_api_tools a resource should always be represented in the same way.
 
 To use a serializer in a controller you should instantiate an instance of the serializer for the top level type you're serializing and pass it to render.
 
@@ -34,7 +34,7 @@ To use a serializer in a controller you should instantiate an instance of the se
 
 
 #### Nesting vs Sideloading
-The big difference between these formats is thttp_api_tools nesting represents the relationships between resources implicitly in it's structure whereas sideloading is a flattened structure with relationships represented via linked identifiers. The details of these formats will be described in more detail below.
+The big difference between these formats is http_api_tools nesting represents the relationships between resources implicitly in it's structure whereas sideloading is a flattened structure with relationships represented via linked identifiers. The details of these formats will be described in more detail below.
 
 
 #### Serializer Definition
@@ -128,7 +128,7 @@ As with sideloading serializers, by default, only the ids of related objects wil
 }
 ```
 
-One advantage to this approach is thttp_api_tools it's always clear whttp_api_tools relationships exist for a resource, even if you don't
+One advantage to this approach is http_api_tools it's always clear what relationships exist for a resource, even if you don't
 include the resources themselves in the response.
 
 ##### Serializing related resources via includes
@@ -219,10 +219,10 @@ and the following when nested:
 }
 ```
 
-One benefit to sideloading over nesting resources is thttp_api_tools if the same resource is referenced multiple times, it only needs to be serialized once. Depending on your data, this may or may not be significant.
+One benefit to sideloading over nesting resources is http_api_tools if the same resource is referenced multiple times, it only needs to be serialized once. Depending on your data, this may or may not be significant.
 
 ##### Including related resources via the url
-It's possible to determine whttp_api_tools resources to include by providing a query string parameter:
+It's possible to determine what resources to include by providing a query string parameter:
 
 `http://example.com/users/1?include?comments,posts.comments`
 
@@ -240,15 +240,15 @@ and/or active record queries:
 
 When providing the includes for an active record query, we actually want a deeper set of includes in order to account for the ids fetched for has_many relationships. If we passed the same set of includes to the query as we pass to the serializer, we'd end up with n+1 queries when fetching the ids for the has_many relationships.
 
-Calling `relation_includes.for_query(UserSerializer)` will figure out the minimum set of includes thttp_api_tools are required based on the following:
+Calling `relation_includes.for_query(UserSerializer)` will figure out the minimum set of includes http_api_tools are required based on the following:
 
 * The models and their relationships
 * The relationships actually being serialized
 
-**** Note thttp_api_tools this particular API is pretty rough at the moment and likely to change once we find a nicer way of describing this feature.
+**** Note http_api_tools this particular API is pretty rough at the moment and likely to change once we find a nicer way of describing this feature.
 
-##### Restricting whttp_api_tools is included
-Once you expose whttp_api_tools can be included as a query string parameter you risk exposing too much information or poorly considered api calls thttp_api_tools fetch too much. This can be countered by defining whttp_api_tools is `includable` for each serializer when it's being used as the root serializer for a json response.
+##### Restricting what is included
+Once you expose what can be included as a query string parameter you risk exposing too much information or poorly considered api calls http_api_tools fetch too much. This can be countered by defining what is `includable` for each serializer when it's being used as the root serializer for a json response.
 
 ```ruby
 class UserSerializer
@@ -267,9 +267,9 @@ class UserSerializer
 end
 ```
 
-This will ensure thttp_api_tools regardless of whttp_api_tools is declared in the `include` param, no more than the allowable includes are ever returned.
+This will ensure http_api_tools regardless of what is declared in the `include` param, no more than the allowable includes are ever returned.
 
-To help in documenting whttp_api_tools is includable, both the includable and included relations are returned in the meta data of the response.
+To help in documenting what is includable, both the includable and included relations are returned in the meta data of the response.
 
 ```javascript
 "meta": {
@@ -300,22 +300,22 @@ of meta-data. At this point, it will always return the `type` and `root_key` for
 }
 ```
 
-Notice thttp_api_tools the root is an array and the root_key a plural. This is the case regardless of whether a single resource
+Notice http_api_tools the root is an array and the root_key a plural. This is the case regardless of whether a single resource
 is being represented or a collection of resources. This is in line with the json-api spec and generally simplifies both serialization and deserialization.
 
 ##### Adding Metadata
-It might be desirable to add extra metadata to the serialized response. For example, adding information such as limit, offset, whttp_api_tools includes are valid etc can be helpful to a client.
+It might be desirable to add extra metadata to the serialized response. For example, adding information such as limit, offset, what includes are valid etc can be helpful to a client.
 
 `UserSerializer.new(user).meta(limit: 10, offset: 0)`
 
 
 
 ### Deserialization
-The `HttpApiTools::JsonDeserializer` expects json in the format thttp_api_tools the serializer has created making it easy to create matching rest apis and clients with little work needing to be done at each end. Currently only sideloaded json can be deserialized. Nested deserializers are coming.
+The `HttpApiTools::JsonDeserializer` expects json in the format http_api_tools the serializer has created making it easy to create matching rest apis and clients with little work needing to be done at each end. Currently only sideloaded json can be deserialized. Nested deserializers are coming.
 
 `HttpApiTools::JsonDeserializer.new(json).deserialize`
 
-This will iterate over the json, using the attribute names to match types to models in the client app. As long as models exist with names thttp_api_tools match the keys in the json, a complete graph of objects will be created upon deserialization, complete with two way relationships when they exist.
+This will iterate over the json, using the attribute names to match types to models in the client app. As long as models exist with names http_api_tools match the keys in the json, a complete graph of objects will be created upon deserialization, complete with two way relationships when they exist.
 
 In the previous example, the following model classes would be expected:
 
@@ -349,7 +349,7 @@ At times, the name of an object's key may deviate from it's type and can't be de
 }
 ```
 
-In this example, the `user` is the `author` of the `post`. It is impossible to infer from the data thttp_api_tools an `author` attribute key should map to a `User` type so we need to give it a helping hand. This can be done once per type by creating a `JsonDeserializerMapping` class. Like with serializers, deserializer mappings are convention based, using the model class name as a prefix.
+In this example, the `user` is the `author` of the `post`. It is impossible to infer from the data http_api_tools an `author` attribute key should map to a `User` type so we need to give it a helping hand. This can be done once per type by creating a `JsonDeserializerMapping` class. Like with serializers, deserializer mappings are convention based, using the model class name as a prefix.
 
 ```ruby
 class PostDeserializerMapping
@@ -376,7 +376,7 @@ end
 ```
 
 ### Models
-Client models have some basic requirements thttp_api_tools are catered to such as attribute definition, default values and type tranforms.
+Client models have some basic requirements http_api_tools are catered to such as attribute definition, default values and type tranforms.
 
 For example:
 
@@ -438,7 +438,7 @@ end
 ```
 
 #### Read only attributes
-Sometimes it's useful to define a field as readonly. The intent being thttp_api_tools we prevent changing an attribute value thttp_api_tools shouldn't be changed or prevent a value from being serialized and sent in the payload thttp_api_tools the server won't accept.
+Sometimes it's useful to define a field as readonly. The intent being http_api_tools we prevent changing an attribute value http_api_tools shouldn't be changed or prevent a value from being serialized and sent in the payload http_api_tools the server won't accept.
 
 In the previous example, it might be better to set the `created_at` field as readonly:
 
@@ -466,7 +466,7 @@ At this point, polymorphic relationships are not catered for but they can be whe
 
 ### A note on performance
 Performance is critial for this gem so any changes must be made with this in mind. There is a basic performance
-spec for serialization thttp_api_tools dumps some timings and creates a profile report in `reports/profile_report.html`.
+spec for serialization http_api_tools dumps some timings and creates a profile report in `reports/profile_report.html`.
 
 Until we have a more robust way of tracking performance over time, please do some before and after tests against this when you make changes. Even small things have been found to introduce big performance issues.
 

data/lib/http_api_tools/model/acts_like_active_model.rb

@@ -1,4 +1,4 @@
-#Adds methods thttp_api_tools help a client to behave as if it's dealing with an ActiveModel object.
+#Adds methods http_api_tools help a client to behave as if it's dealing with an ActiveModel object.
 #Principle of least surprise here - if someone is working in Rails and using a model it should
 #feel normal and they should be able to do all the things the'd do with an active model object except
 #interact with the database.

data/lib/http_api_tools/relation_includes.rb

@@ -1,7 +1,7 @@
 require 'active_support/core_ext'
 require 'http_api_tools/expanded_relation_includes'
 
-# Hopefully the spec is robust enough thttp_api_tools we can
+# Hopefully the spec is robust enough http_api_tools we can
 # break this down and refactor as we go. I'm not
 # happy with the complexity of it, but it's a
 # reasonably complex problem

data/lib/http_api_tools/serializer_loader.rb

@@ -0,0 +1,19 @@
+module HttpApiTools
+  class SerializerLoader
+
+    def load_serializers
+
+      file_names = Dir.entries(Rails.root.join('app', 'serializers')).select { |file_name| file_name.end_with?('serializer.rb') }.reverse
+
+      file_names.each do |file_name|
+        require file_name
+      end
+
+    rescue StandardError => e
+
+      #no serializers directory found to load
+
+    end
+
+  end
+end

data/lib/http_api_tools/version.rb

@@ -1,3 +1,3 @@
 module HttpApiTools
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/http_api_tools.rb

@@ -6,5 +6,7 @@ require 'http_api_tools/model'
 require 'http_api_tools/relation_includes'
 
 module HttpApiTools
-  # Your code goes here...
+
+  #Make sure all serializers have been loaded so that relationships can be properly resolved
+  SerializerLoader.load_serializers
 end

data/spec/http_api_tools/model/attributes_spec.rb

@@ -97,7 +97,7 @@ module HttpApiTools
 
             end
 
-            it "only allows reading of thttp_api_tools attribute" do
+            it "only allows reading of http_api_tools attribute" do
               expect{ test_model.created_at = Time.now }.to raise_error(NoMethodError)
               expect(test_model.created_at).to be_nil
             end

data/spec/http_api_tools/nesting/json_serializer_spec.rb

@@ -22,7 +22,7 @@ module HttpApiTools
       end
 
       describe "serialization of data" do
-        context "with a single top-level serializable object thttp_api_tools has relationship names different to model class" do
+        context "with a single top-level serializable object http_api_tools has relationship names different to model class" do
 
           context "without any includes" do
 
@@ -74,7 +74,7 @@ module HttpApiTools
               expect(serialized[:meta][:includable]).to eq '*'
             end
 
-            it "includes whttp_api_tools was included in meta" do
+            it "includes what was included in meta" do
               expect(serialized[:meta][:included]).to eq 'employer,skills,skills.person'
             end
 
@@ -157,11 +157,11 @@ module HttpApiTools
             expect(limited_serialized[:skills]).to be_nil
           end
 
-          it "includes whttp_api_tools is includable in meta" do
+          it "includes what is includable in meta" do
             expect(limited_serialized[:meta][:includable]).to eq 'skills'
           end
 
-          it "includes whttp_api_tools was included in meta" do
+          it "includes what was included in meta" do
             expect(limited_serialized[:meta][:included]).to eq 'skills'
             expect(unlimited_serialized[:meta][:included]).to eq 'employer,skills,skills.person'
           end

data/spec/http_api_tools/sideloading/json_serializer_spec.rb

@@ -22,7 +22,7 @@ module HttpApiTools
       end
 
       describe "serialization of data" do
-        context "with a single top-level serializable object thttp_api_tools has relationship names different to model class" do
+        context "with a single top-level serializable object http_api_tools has relationship names different to model class" do
 
           context "without any includes" do
 
@@ -158,11 +158,11 @@ module HttpApiTools
             expect(limited_serialized[:linked][:people]).to be_nil
           end
 
-          it "includes whttp_api_tools is includables in meta" do
+          it "includes what is includables in meta" do
             expect(limited_serialized[:meta][:includable]).to eq 'employer,skills'
           end
 
-          it "includes whttp_api_tools was included in meta" do
+          it "includes what was included in meta" do
             expect(limited_serialized[:meta][:included]).to eq 'employer,skills'
             expect(unlimited_serialized[:meta][:included]).to eq 'employer,skills,skills.person'
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http_api_tools
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Rob Monie
@@ -136,6 +136,7 @@ files:
 - lib/http_api_tools/nesting/json_serializer.rb
 - lib/http_api_tools/nesting/relation_loader.rb
 - lib/http_api_tools/relation_includes.rb
+- lib/http_api_tools/serializer_loader.rb
 - lib/http_api_tools/serializer_registry.rb
 - lib/http_api_tools/sideloading/json_deserializer.rb
 - lib/http_api_tools/sideloading/json_deserializer_mapping.rb