deserializer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e0dd737dc7e4c34c7238b6dc22a16077e17c22d3
+  data.tar.gz: 1d3b4c23174de67667241f4dc91109222bc61d41
+SHA512:
+  metadata.gz: d9c5cde9d336f5568761d3d91b39cc697dead376ac6d7f3260da7901aaac333961a71fe7ff1fb0eb7e72446de88b9282e3c850b9c3198aa89fbb92404f2713f0
+  data.tar.gz: bcedd5145f9015da536d2927bed7fcca82d0b39796e78dc7fd6877da719ce2b9f1e5e31a7d5fd2b60c34b4dd5e46fa4d720829046f4eca2c8691a7fdb07e4fa2

data/.gitignore

@@ -0,0 +1,8 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3-journal
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Declare your gem's dependencies in deserializer.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]
+

data/Gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: .
+  specs:
+    deserializer (0.0.1)
+      rails (~> 4.2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.2.3)
+      actionpack (= 4.2.3)
+      actionview (= 4.2.3)
+      activejob (= 4.2.3)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+    actionpack (4.2.3)
+      actionview (= 4.2.3)
+      activesupport (= 4.2.3)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.3)
+      activesupport (= 4.2.3)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    activejob (4.2.3)
+      activesupport (= 4.2.3)
+      globalid (>= 0.3.0)
+    activemodel (4.2.3)
+      activesupport (= 4.2.3)
+      builder (~> 3.1)
+    activerecord (4.2.3)
+      activemodel (= 4.2.3)
+      activesupport (= 4.2.3)
+      arel (~> 6.0)
+    activesupport (4.2.3)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.2)
+    builder (3.2.2)
+    erubis (2.7.0)
+    globalid (0.3.5)
+      activesupport (>= 4.1.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    loofah (2.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.6.3)
+      mime-types (>= 1.16, < 3)
+    mime-types (2.6.1)
+    mini_portile (0.6.2)
+    minitest (5.7.0)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    rack (1.6.4)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails (4.2.3)
+      actionmailer (= 4.2.3)
+      actionpack (= 4.2.3)
+      actionview (= 4.2.3)
+      activejob (= 4.2.3)
+      activemodel (= 4.2.3)
+      activerecord (= 4.2.3)
+      activesupport (= 4.2.3)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.2.3)
+      sprockets-rails
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.6)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.2)
+      loofah (~> 2.0)
+    railties (4.2.3)
+      actionpack (= 4.2.3)
+      activesupport (= 4.2.3)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.4.2)
+    sprockets (3.2.0)
+      rack (~> 1.0)
+    sprockets-rails (2.3.2)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
+    sqlite3 (1.3.10)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  deserializer!
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Greg Orlov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,268 @@
+# Deserializer
+
+Deserialization of complex parameters into a hash that an AR model can take. 
+
+Lets you have a reverse ActiveModel::Sereializer-like interface that allows for easy create and update without having to write heavy controllers.
+
+## Problem
+
+Let's say we have a API create endpoint that takes json that looks something like
+
+```json
+{
+  "restaurant_id" : 13,
+        "user_id" : 6,
+      "dish_name" : "risotto con funghi",
+    "description" : "repulsive beyond belief",
+        "ratings" : {
+                        "taste" : "terrible",
+                        "color" : "horrendous",
+                      "texture" : "vile",
+                        "smell" : "delightful, somehow"
+                    }
+}
+```
+
+that goes into a flat DishReview model that looks like
+
+```ruby
+t.belongs_to  :restaurant
+t.belongs_to  :user
+# field name different from API
+t.string      :name
+t.string      :description
+t.string      :taste
+t.string      :color
+t.string      :texture
+t.string      :smell
+```
+
+what do we do?
+
+Normally, we'd have some params we permit, do some parsing and feed those into `DishReview.new`, like
+
+``` ruby
+class DishReviewController < BaseController
+
+  def create
+    review_params = get_review_params(params)
+    @review = ProfessionalReview.new(review_params)
+    if @review.save
+      # return review
+    else
+      # return sad errors splody
+    end
+  end
+
+  # rest of RUD
+
+  protected
+
+  def permitted_params
+   [
+      :restaurant_id,
+      :user_id
+      :dish_name,
+      :description,
+      :taste,
+      :color,
+      :texture,
+      :smell
+    ]
+  end
+
+  def get_review_params(params)
+    review_params = params.require(:review)
+
+    review_params[:name] ||= review_params.delete(:dish_name)
+
+    ratings = review_params.delete(:ratings)
+    if (ratings.present?)
+      ratings.each{|rating, value| review_params[rating] = value if valid_rating?(rating) }
+    end
+
+    review_params.permit(permitted_params)
+  end
+
+  def valid_rating?(rating)
+    @@ratings ||= ["overall", "trusthworthy", "responsive", "knowledgeable", "communication"]
+
+    @@ratings.include? rating
+
+  end
+end
+```
+
+and that's fine, but kind of annoying, and you have to do this for every action. It makes the controllers heavy, hard to parse, fragile, and really do things that are no longer controller-y. 
+
+So what we have here is a wrapper that lets us get away from polluting the controller with all of this parsing and lets us build deserializers that look very much like our serializers. 
+
+## Usage
+
+Deserializer acts and looks pretty mich identical to ActiveModel::Serializer. It has attributes, attribute, and the has_one association. It does not currently support has_many, as that's an odd thing for a write endpoint to support, but can easily be added. 
+
+### Deserializer functions
+
+#### from_params
+`MyDeserializer.from_params(params)` created the json that your AR model will then consume. 
+```ruby
+@review = DishReview.new( MyApi::V1::DishReviewDeserailzer.from_params(params) )
+```
+
+#### permitted_params
+If you're using strong params, this lets you avoid having multiple definitions in fragile arrays. Just call ` MyDeserailzer.permitted_params` and you'll have the full array of keys you expect params to have.
+
+### Deserializer Definition
+To define a deserializer, you inherit from `Deserializer::Base` and define it in much the same way you would an `ActiveModel::Serializer`. 
+
+#### attributes
+This is straight 1:1 mapping from params to the model, so 
+
+```ruby
+class PostDeserializer < Deserializer::Base
+  attributes  :title,
+              :body
+end
+```
+with params `{"title" => "lorem", "body" => "ipsum"}`, will give you a hash of `{title: "lorem", body: "ipsum"}`.
+
+#### attribute
+`attribute` is the singular version of `attributes`, but like `ActiveModel::Serializer` it can take a `:key`
+```ruby
+class PostDeserializer < Deserializer::Base
+  attribute :title
+  attribute :body, key: :text
+end
+```
+It is symmetric with `ActiveModel::Serializer`, so that :text is what it will get in params, but :body is what it will insert into the result. 
+
+For example with params of `{"title" => "lorem", "text" => "ipsum"}` this desrerializer will produce `{title: "lorem", body: "ipsum"}`.
+
+
+#### has_one
+NOTE: This is the only association currently supported by `Deserializer`.
+`has_one` expects the param and its deserializer. So for params `{"ratings" => {"taste" => "bad", "smell" => "good"}}`
+```ruby 
+class DishDeserializer < Deserializer::Base
+  # probably other stuff
+  has_one :ratings, deserializer: RatingsDeserializer
+end
+
+class RatingsDeserializer < Deserializer::Base
+  attributes  :taste,
+              :smell
+end
+```
+you would get `{ratings: {taste: "bad", smell: "good"}}`
+
+#### Overriding Attribute Methods
+So let's say in the example above, your internal representation of ratings inside `Dish` is actually called `scores`, you can do
+```ruby
+class DishDeserializer < Deserializer::Base
+  has_one :ratings, deserializer: RatingsDeserializer
+
+  def ratings
+    :scores
+  end
+end
+```
+which will give you `{scores: {taste: "bad", smell: "good"}}`
+
+or, if you want to deserialize `ratings` into your `dish` object, you can use `object`
+
+```ruby
+class DishDeserializer < Deserializer::Base
+  has_one :ratings, deserializer: RatingsDeserializer
+
+  def ratings
+    object
+  end
+end
+```
+which will give you `{taste: "bad", smell: "good"}`
+
+or you can deserialize into another subobject by doing
+```ruby
+class DishDeserializer < Deserializer::Base
+  has_one :colors,  deserializer: ColorsDeserializer
+  has_one :ratings, deserializer: RatingsDeserializer
+
+  def colors
+    object[:ratings]
+  end
+end
+```
+which, given params 
+```
+{ 
+  "ratings" => 
+    { 
+      "taste" => "bad",
+      "smell" => "good"
+    }, 
+  "colors" => 
+    { 
+      "color" => "red"
+    }
+}
+```
+, will give you `{ratings: {taste: "bad", smell: "good", color: "red"}}`
+
+### Example
+
+So the example above will combine all of those to look like 
+
+```ruby
+module MyApi
+  module V1
+    class DishReviewDeserializer < Deserializer::Base
+      attributes  :restaurant_id
+                  :user_id
+                  :description
+
+      attribute   :name, key: :dish_name
+
+      has_one :ratings, :deserializer => RatingsDeserializer
+
+      def ratings
+        object
+      end
+
+    end
+  end
+end
+```
+
+where RatingsDeserializer looks like
+
+```ruby
+module MyApi
+  module V1
+    class RatingsDeserializer < Deserializer::Base
+
+      attributes  :taste,
+                  :color,
+                  :texture,
+                  :smell
+    end
+  end
+end
+```
+
+All of this allows your controller to be so very small, like
+
+```ruby
+class DishReviewsController < YourApiController::Base
+  def create
+    @review = DishReview.new( MyApi::V1::DishReviewDeserailzer.from_params(params) )
+
+    if @review.save
+      # return review
+    else
+      # return sad errors splody
+    end
+  end
+
+  # rest of RUD
+end
+```

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Deserializer'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test