model_view 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bbb9e6927b9d2a9a2350d4b2b9fa3bb914a125d
-  data.tar.gz: 58d8e67a612acda3b04469af9573ef2f71bfc2bb
+  metadata.gz: 7c5dbabbb8d69d5dadabc4592e8ac4dc6c705c26
+  data.tar.gz: 226889168c0093984f854e7717e5decf9658c19f
 SHA512:
-  metadata.gz: 68014a9a7f17ad08e169fed2cb92d2582e886821e51bb7690412cec03263a97204bd1c80f127855f907ef52050abbbf42c5edf0b52e57fe64f99d3ab81233250
-  data.tar.gz: 4283cf11f8300868265c6763fef87a6626d0cd61926bfa822fc7b23099848ba4e12d68f60fd8f59d174e05657cec2b2497657090d714aa75373429ccdb13da22
+  metadata.gz: 526855a236a1e2f026da812c2deca02ef02b174f7e0d37f44da02a4d5783ebc98c013c04efe2909b5cf3b451d6dafd01fa50b0f6c6a617852296bd2d0eaea0db
+  data.tar.gz: 1cdb32908ed57177c8f278d7af4730549a5b57fe5ad30555e32bcbf42c3e5faeb8eb3711a9f20663b2134d9062cac0a31a4e912d60270da698801fb8d2af8bbe

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+# 0.3.0
+* ModelView can be used to update models
+
+
 # 0.2.0
 * ModelView can add a convenience method to the model class
 

data/README.md

@@ -33,7 +33,7 @@ field :name
 
 field(:first_name) { |person| person.name.split(' ').first }
 
-field :is_current_user, context[:current_user] do |person, current_user|
+field :is_current_user, {context: current_user} do |person, current_user|
   person == current_user
 end
 ```
@@ -130,3 +130,40 @@ PersonView.as_hash(person, {context: {current_user: current_user}, scope: :all})
   is_current_user: true
 }
 ```
+
+#### Updating models
+`ModelView` can also be used to update models. This is achieved by creating setters.
+
+The easiest way to create a setter is to set the `setter` flag to true when defining a field:
+```ruby
+field :name, setter: true
+```
+
+Setters can also be defined outside of the `field` macro:
+```ruby
+setter :name
+```
+
+Setters defined in this way are naive (`obj.send("#{field}=", value)`) and will not automatically call the `save` method on the model. See below on how to create an `after_update` hook.
+
+Finally, for more complex updaters, a block can be passed:
+```ruby
+setter(:name) do |obj, name|
+  first_name, last_name = name.split(" ")
+  obj.first_name = first_name
+  obj.last_name = last_name
+  obj.save!
+end
+```
+
+To avoid having to explicitly save the model in every block, one can define an `after_save` block:
+```ruby
+after_save { |obj| obj.save! }
+
+field :telephone_number, setter: true
+setter(:name) do |obj, name|
+  first_name, last_name = name.split(" ")
+  obj.first_name = first_name
+  obj.last_name = last_name
+end
+```

data/lib/model_view/updater.rb

@@ -0,0 +1,76 @@
+module ModelView
+  class Updater
+
+    class << self
+      def update(obj, scopes, data, scope=nil)
+        scope ||= ModelView::ROOT
+
+        setters = setters_for_scope(scope, scopes)
+
+        data.each do |key, value|
+          setter = if !setters[key].nil?
+            setter_for_key(setters, key)
+          else
+            nil
+          end
+
+          setter.call(obj, value) if setter
+        end
+
+        after_update = after_update_for_scope(scope, scopes)
+        after_update.call(obj) if after_update
+      end
+
+      private
+      def setter_for_key(setters, key)
+        return nil if setters[key].nil?
+        if setters[key][:block]
+          setters[key][:block]
+        else
+          lambda { |obj, value| obj.send("#{key}=", value) }
+        end
+      end
+
+      def after_update_for_scope(scope, scopes)
+        extended_scopes = scopes[scope][:extends] || []
+        first_extended_after_update = extended_scopes.reduce(nil) do |res, s|
+          res || extract_after_update(s, scopes)
+        end
+
+        extract_after_update(scope, scopes) ||
+        first_extended_after_update ||
+        extract_after_update(ModelView::ROOT, scopes)
+
+      end
+
+      def setters_for_scope(scope, scope_data)
+        root_scope_setters = extract_setters(ModelView::ROOT, scope_data)
+        scope_setters = scope == ModelView::ROOT ? {} : extract_setters(scope, scope_data)
+
+        extended_scopes = scope_data[scope][:extends] || []
+        extended_setters = extended_scopes.reduce({}) do |res, scope|
+          res.merge(extract_setters(scope, scope_data))
+        end
+
+        included_setters = (scope_data[scope][:includes] || []).reduce({}) do |res, scope_name|
+          res[scope_name] = setters_for_scope(scope_name, scope_data)
+          res
+        end
+
+        {}.merge(root_scope_setters)
+          .merge(scope_setters)
+          .merge(extended_setters)
+          .merge(included_setters)
+      end
+
+      def extract_setters(scope, scope_data)
+        scope_data[scope][:setters]
+      end
+
+      def extract_after_update(scope, scope_data)
+        scope_data[scope][:after_update]
+      end
+
+    end
+  end
+end

data/lib/model_view/version.rb

@@ -1,3 +1,3 @@
 module ModelView
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/model_view.rb

@@ -1,4 +1,5 @@
 require 'model_view/resolver'
+require 'model_view/updater'
 
 module ModelView
 
@@ -22,6 +23,11 @@ module ModelView
     @current_scope = nil
   end
 
+  def setter(field_name, arg={}, &block)
+    scope_name = @current_scope || ROOT
+    add_setter scope_name, field_name, arg, block
+  end
+
   def include_scope(*scope)
     raise Exception.new("Root scope can not include another scope") if @current_scope.nil? || @current_scope == ROOT
     scope.flatten.each { |s| @scopes[@current_scope][:includes] << s }
@@ -32,6 +38,11 @@ module ModelView
     scope.flatten.each { |s| @scopes[@current_scope][:extends] << s }
   end
 
+  def after_update(&block)
+    scope_name = @current_scope || ROOT
+    add_after_update scope_name, block
+  end
+
   def scopes
     @scopes
   end
@@ -42,6 +53,11 @@ module ModelView
     ModelView::Resolver.resolve(object, @scopes, scope , context)
   end
 
+  def update(object, data, opts={})
+    scope = opts[:scope] || ROOT
+    ModelView::Updater.update(object, @scopes, data , scope)
+  end
+
   def model(model_class)
     model_view_class = self
     model_class.class_eval do
@@ -53,15 +69,34 @@ module ModelView
 
   private
 
+  def new_opts
+    {fields: {}, extends: [], includes: [], setters: {}, after_update: nil}
+  end
+
+  def add_after_update(scope, block)
+    @scopes ||= {ROOT =>  new_opts}
+    @scopes[scope] ||= new_opts
+    @scopes[scope][:after_update] = block
+  end
+
   def add_scope(scope_name)
-    @scopes ||= {ROOT =>  {fields: {}, extends: [], includes: []}}
-    @scopes[scope_name] = {fields: {}, extends: [], includes: []}
+    @scopes ||= {ROOT => new_opts}
+    @scopes[scope_name] = new_opts
   end
 
   def add_field(scope, field_name, args, block)
-    @scopes ||= {ROOT =>  {fields: {}, extends: [], includes: []}}
-    @scopes[scope] ||= {fields: {}, extends: [], includes: []}
-    @scopes[scope][:fields][field_name] = {args: args, block: block}
+    @scopes ||= {ROOT =>  new_opts}
+    @scopes[scope] ||= new_opts
+    if args[:setter]
+      add_setter(scope, field_name, {}, nil)
+    end
+    @scopes[scope][:fields][field_name] = {args: args.select{ |k| k != :setter}, block: block}
+  end
+
+  def add_setter(scope, field_name, args, block)
+    @scopes ||= {ROOT =>  new_opts}
+    @scopes[scope] ||= new_opts
+    @scopes[scope][:setters][field_name] = {args: args, block: block}
   end
 
 end

data/spec/model_view/model_view_spec.rb

@@ -23,6 +23,18 @@ describe ModelView do
             expect(scope_fields[:a_field]).to eq({args: {foo: 1}, block: nil})
           end
         end
+
+        context "with setter set to true" do
+          it "adds the field and setter to the root scope" do
+            dummy_class.field :a_field, {setter: true}
+
+            scope_fields = dummy_class.scopes[root_scope][:fields]
+            expect(scope_fields[:a_field]).to eq({args: {}, block: nil})
+
+            scope_setters = dummy_class.scopes[root_scope][:setters]
+            expect(scope_setters[:a_field]).to eq({args: {}, block: nil})
+          end
+        end
       end
 
       context "with a block" do
@@ -57,6 +69,37 @@ describe ModelView do
         expect { dummy_class.extend_scope :a_field }.to raise_error "Root scope can not extend another scope"
       end
     end
+
+    describe :setter do
+      context "without a block" do
+        it "adds the setter to the root scope" do
+          dummy_class.setter :a_field
+
+          scope_setters = dummy_class.scopes[root_scope][:setters]
+          expect(scope_setters[:a_field]).to eq({args: {}, block: nil})
+        end
+      end
+
+      context "with a block" do
+        it "adds the seter to the root scope" do
+          dummy_class.setter :a_field { 1 + 1 }
+
+          scope_setters = dummy_class.scopes[root_scope][:setters]
+
+          expect(scope_setters[:a_field][:args]).to eq({})
+          expect(scope_setters[:a_field][:block].call).to eq(2)
+        end
+      end
+    end
+
+    describe :after_update do
+      it "adds an after_update block" do
+        dummy_class.after_update { |obj| obj.save }
+
+        after_update = dummy_class.scopes[root_scope][:after_update]
+        expect(after_update).to be_a(Proc)
+      end
+    end
   end
 
   context "within a scope" do
@@ -142,6 +185,29 @@ describe ModelView do
         end
       end
     end
+
+    describe :setter do
+      context "without a block" do
+        it "adds the setter to the root scope" do
+          dummy_class.scope :my_scope { setter :a_field }
+
+          scope_setters = dummy_class.scopes[:my_scope][:setters]
+          expect(scope_setters[:a_field]).to eq({args: {}, block: nil})
+        end
+      end
+
+      context "with a block" do
+        it "adds the seter to the root scope" do
+          dummy_class.scope :my_scope { setter :a_field { 1 + 1 } }
+
+          scope_setters = dummy_class.scopes[:my_scope][:setters]
+
+          expect(scope_setters[:a_field][:args]).to eq({})
+          expect(scope_setters[:a_field][:block].call).to eq(2)
+        end
+      end
+    end
+
   end
 
   describe :model do

data/spec/model_view/resolver_spec.rb

@@ -130,6 +130,5 @@ describe ModelView::Resolver do
       end
     end
 
-
   end
 end

data/spec/model_view/updater_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'pry'
+
+describe ModelView::Updater do
+  let(:scopes) do
+    {
+      __root__: {
+        fields: {
+          field1: {},
+          field2: {},
+          field3: {}
+        },
+        setters: {
+          field1: {},
+          field3: {block: Proc.new { |obj, data| obj.field3 = data + 2 }}
+        },
+        after_update: Proc.new { |obj| obj.save }
+      },
+      scope1: {
+        fields: {
+          field4: {block: Proc.new { |obj| obj.field4 + obj.field1 }},
+          field5: {},
+          field6: {}
+        },
+        setters: {
+          field4: {block: Proc.new { |obj, data| obj.field4 = data }},
+          field5: {},
+          field6: {}
+        }
+      },
+      scope2: {
+        extends: [:scope1],
+        fields: {
+          field7: {},
+          field8: {},
+          field9: {}
+        },
+        setters: {
+          field7: {}
+        }
+      },
+      scope3: {
+        includes: [:scope1],
+        fields: {
+          field10: {},
+          field11: {},
+          field12: {}
+        },
+        setters: {
+          field10: {}
+        }
+      }
+    }
+  end
+
+  describe :update do
+    before do
+      class Dummy
+        attr_accessor *(1..12).map { |n| "field#{n}".to_sym }
+
+        def save
+
+        end
+      end
+    end
+
+    let(:instance) { Dummy.new }
+
+    context "for the root scope" do
+      let(:data) { {field1: 1, field2: 2, field3: 2} }
+      context "for a setter without a block" do
+        it "sets the values with setters" do
+          ModelView::Updater.update(instance, scopes, data)
+          expect(instance.field1).to eq(1)
+        end
+
+        it "does not set the values without setters" do
+          ModelView::Updater.update(instance, scopes, data)
+          expect(instance.field2).to be_nil
+        end
+
+        it "uses a block to set the value, if available" do
+          ModelView::Updater.update(instance, scopes, data)
+          expect(instance.field3).to eq(4)
+        end
+
+        it "runs the after_update block, if provided" do
+          expect(instance).to receive(:save)
+          ModelView::Updater.update(instance, scopes, data)
+        end
+      end
+    end
+
+    context "on a scope" do
+      it "includes the root level setters" do
+        data = {field1: 1, field4: 4}
+        ModelView::Updater.update(instance, scopes, data, :scope1)
+
+        expect(instance.field1).to eq(1)
+        expect(instance.field4).to eq(4)
+      end
+    end
+
+    context "on a scope extending another scope" do
+      it "also includes the extended scope's setters" do
+        data = {field7: 7, field4: 4}
+        ModelView::Updater.update(instance, scopes, data, :scope2)
+
+        expect(instance.field7).to eq(7)
+        expect(instance.field4).to eq(4)
+      end
+    end
+
+    context "on a scope including another scope" do
+      it "also includes the included scope's setters"
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: model_view
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Martin Pretorius
@@ -96,10 +96,12 @@ files:
 - README.md
 - lib/model_view.rb
 - lib/model_view/resolver.rb
+- lib/model_view/updater.rb
 - lib/model_view/version.rb
 - model_view.gemspec
 - spec/model_view/model_view_spec.rb
 - spec/model_view/resolver_spec.rb
+- spec/model_view/updater_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Offerzen/model_view
 licenses:
@@ -128,4 +130,5 @@ summary: Composable serialisation for models
 test_files:
 - spec/model_view/model_view_spec.rb
 - spec/model_view/resolver_spec.rb
+- spec/model_view/updater_spec.rb
 - spec/spec_helper.rb