model_view 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f688defb10471b902321d51a00192f047d6e552f
-  data.tar.gz: f1ebe9dfbb0be1624b6587354107ea7d4756adaa
+  metadata.gz: e1dc28eafd2cab5fd5c515e0a011d19240bb9244
+  data.tar.gz: 4983872ab1e955511334fae65c404d0348d5cae2
 SHA512:
-  metadata.gz: 3861230b60541e95df07e21e6a8ae5b62f1bdf2f0646cb7cab896ac7252d5b8ffe11c9b32bc96cb4bf65f4521b3891c57997470dd4ccdddcaf162e601f78275b
-  data.tar.gz: 7675da184fda990dab7d96dad3e144aa3239db19734f25e65a16c04189b592cb671e4bc58580027f4f4c2b096956c9e8b9496bf494a90256f958b09dc8800881
+  metadata.gz: 4a922409b4e094409d70a5aafd16ed365f5b9ca97cd2f4350bb5a27b373de46972b4d4dd2535fee6b4dfde9367505a92dcdc35b6e50fe31e859c2fda4b4942da
+  data.tar.gz: 63101e9b84430de3fb973d28301e921fcb743a22ca6feb0c6d38481b7b9259cc6b307c1efabf7d1fd43ae7014773a69066d1eb7498911c0b8ed37f85118637bb

data/.gem_server

@@ -0,0 +1 @@
+rubygems.org

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+# 0.1.0
+* Initial release
+

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/lib/model_view/resolver.rb

@@ -0,0 +1,58 @@
+module ModelView
+  class Resolver
+
+    class << self
+      def resolve(obj, scopes, scope=nil, context={})
+        scope ||= ModelView::ROOT
+
+        fields = fields_for_scope(scope, scopes)
+
+        fields.each_with_object({}) do |(field_name, field_data), result|
+          result[field_name] = evaluate_field(obj, field_name, field_data[:args], field_data[:block], context)
+        end
+
+      end
+
+      def fields_for_scope(scope, scope_data)
+        root_scope_fields = extract_fields(ModelView::ROOT, scope_data)
+        scope_fields = scope == ModelView::ROOT ? {} : extract_fields(scope, scope_data)
+
+        extended_scopes = scope_data[scope][:extends] || []
+        extended_fields = extended_scopes.reduce({}) do |res, scope|
+          res.merge(extract_fields(scope, scope_data))
+        end
+
+        included_scopes = (scope_data[scope][:includes] || []).reduce({}) do |res, scope_name|
+          res[scope_name] = fields_for_scope(scope_name, scope_data)
+          res
+        end
+
+        {}.merge(root_scope_fields)
+          .merge(scope_fields)
+          .merge(extended_fields)
+          .merge(included_scopes)
+      end
+
+      private
+
+      def evaluate_field(object, field_name, options, block, context)
+        if block.nil?
+          object.send(field_name)
+        else
+          if block.arity == 1
+            block.call(object)
+          else
+            arguments_for_block = options[:context].map { |key| context[key] }
+            block.call(object, *arguments_for_block)
+          end
+        end
+      end
+
+      def extract_fields(scope, scope_data)
+        scope_data[scope][:fields]
+      end
+
+    end
+  end
+
+end

data/lib/model_view/version.rb

@@ -0,0 +1,3 @@
+module ModelView
+  VERSION = "0.1.0"
+end

data/lib/model_view.rb

@@ -0,0 +1,56 @@
+require 'model_view/resolver'
+
+module ModelView
+
+  ROOT = :__root__
+
+  def field(field_name, arg={}, &block)
+    scope_name = @current_scope || ROOT
+    add_field scope_name, field_name, arg, block
+  end
+
+  def fields(*fields)
+    fields.flatten.each { |f| field f }
+  end
+
+  def scope(scope_name, &block)
+    sym_scope_name = scope_name.to_sym
+    add_scope(sym_scope_name)
+
+    @current_scope = sym_scope_name
+    instance_eval &block
+    @current_scope = nil
+  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 }
+  end
+
+  def extend_scope(*scope)
+    raise Exception.new("Root scope can not extend another scope") if @current_scope.nil? || @current_scope == ROOT
+    scope.flatten.each { |s| @scopes[@current_scope][:extends] << s }
+  end
+
+  def scopes
+    @scopes
+  end
+
+  def as_hash(object, scope=nil, context={})
+    ModelView::Resolver.resolve(object, @scopes, scope || ROOT, context)
+  end
+
+  private
+
+  def add_scope(scope_name)
+    @scopes ||= {}
+    @scopes[scope_name] = {fields: {}, extends: [], includes: []}
+  end
+
+  def add_field(scope, field_name, args, block)
+    @scopes ||= {}
+    @scopes[scope] ||= {fields: {}, extends: [], includes: []}
+    @scopes[scope][:fields][field_name] = {args: args, block: block}
+  end
+
+end

data/model_view.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'model_view/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'model_view'
+  spec.version     = ModelView::VERSION
+  spec.date        = '2017-06-13'
+  spec.summary     = "Composable serialisation for models"
+  spec.description = "Composable serialisation for models"
+  spec.authors     = ["Martin Pretorius"]
+  spec.email       = ['martin@offerzen.com', 'glasnoster@gmail.com']
+  spec.homepage    = 'https://github.com/Offerzen/model_view'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "semvergen", "~> 1.9"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake",    "~> 10.0"
+  spec.add_development_dependency "rspec",   "~> 3.0"
+  spec.add_development_dependency "pry",     "~> 0.10"
+end

data/spec/model_view/model_view_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'pry'
+
+describe ModelView do
+  let(:dummy_class) { Class.new { extend ModelView } }
+  let(:root_scope) { :__root__ }
+
+  context "root scope" do
+    describe :field do
+      context "without a block" do
+        it "adds the field to the root scope" do
+          dummy_class.field :a_field
+
+          scope_fields = dummy_class.scopes[root_scope][:fields]
+          expect(scope_fields[:a_field]).to eq({args: {}, block: nil})
+        end
+
+        context "with arguments" do
+          it "adds the field to the root scope" do
+            dummy_class.field :a_field, {foo: 1}
+
+            scope_fields = dummy_class.scopes[root_scope][:fields]
+            expect(scope_fields[:a_field]).to eq({args: {foo: 1}, block: nil})
+          end
+        end
+      end
+
+      context "with a block" do
+        it "adds the field to the root scope" do
+          dummy_class.field :a_field { 1 + 1 }
+
+          scope_fields = dummy_class.scopes[root_scope][:fields]
+
+          expect(scope_fields[:a_field][:args]).to eq({})
+          expect(scope_fields[:a_field][:block].call).to eq(2)
+        end
+      end
+    end
+
+    describe :fields do
+      it "adds all the fields to the root scope" do
+        dummy_class.fields :field_1, :field_2, :field_3
+
+        scope_fields = dummy_class.scopes[root_scope][:fields]
+        expect(scope_fields.keys).to eq([:field_1, :field_2, :field_3])
+      end
+    end
+
+    describe :include_scope do
+      it "raises an error" do
+        expect { dummy_class.include_scope :a_field }.to raise_error "Root scope can not include another scope"
+      end
+    end
+
+    describe :extend_scope do
+      it "raises an error" do
+        expect { dummy_class.extend_scope :a_field }.to raise_error "Root scope can not extend another scope"
+      end
+    end
+  end
+
+  context "within a scope" do
+    describe :scope do
+      it "creates a scope" do
+        dummy_class.scope :a_scope {  }
+
+        expect(dummy_class.scopes.keys).to include(:a_scope)
+      end
+    end
+
+    describe :field do
+      it "adds a field inside the scope" do
+        dummy_class.scope :a_scope { field :foo }
+
+        scope_fields = dummy_class.scopes[:a_scope][:fields]
+        expect(scope_fields.keys).to include(:foo)
+      end
+
+      it "changes the current scope back to root" do
+        dummy_class.scope :a_scope { field :foo }
+        dummy_class.field :bar
+
+        scope_fields = dummy_class.scopes[:a_scope][:fields]
+        root_scope_fields = dummy_class.scopes[root_scope][:fields]
+
+        expect(scope_fields.keys).to include(:foo)
+        expect(root_scope_fields.keys).to include(:bar)
+      end
+    end
+
+    describe :fields do
+      it "adds all the fields to the current scope" do
+        dummy_class.scope :foo_scope { fields :field_1, :field_2, :field_3 }
+
+        scope_fields = dummy_class.scopes[:foo_scope][:fields]
+        expect(scope_fields.keys).to eq([:field_1, :field_2, :field_3])
+      end
+    end
+
+    describe :include_scope do
+      context "given a single scope" do
+        it "adds the scope to the current scope's includes" do
+          dummy_class.scope :my_scope { include_scope :foo }
+          expect(dummy_class.scopes[:my_scope][:includes]).to eq([:foo])
+        end
+      end
+
+      context "given an array" do
+        it "adds all the scopes to the current scope's includes" do
+          dummy_class.scope :my_scope { include_scope [:foo, :bar] }
+          expect(dummy_class.scopes[:my_scope][:includes]).to eq([:foo, :bar])
+        end
+      end
+
+      context "given more than one scope" do
+        it "adds all the scopes to the current scope's includes" do
+          dummy_class.scope :my_scope { include_scope :foo, :bar }
+          expect(dummy_class.scopes[:my_scope][:includes]).to eq([:foo, :bar])
+        end
+      end
+    end
+
+    describe :extend_scope do
+      context "given a single scope" do
+        it "adds the scope to the current scope's extends" do
+          dummy_class.scope :my_scope { extend_scope :foo }
+          expect(dummy_class.scopes[:my_scope][:extends]).to eq([:foo])
+        end
+      end
+
+      context "given an array" do
+        it "adds all the scopes to the current scope's extends" do
+          dummy_class.scope :my_scope { extend_scope [:foo, :bar] }
+          expect(dummy_class.scopes[:my_scope][:extends]).to eq([:foo, :bar])
+        end
+      end
+
+      context "given more than one scope" do
+        it "adds all the scopes to the current scope's extends" do
+          dummy_class.scope :my_scope { extend_scope :foo, :bar }
+          expect(dummy_class.scopes[:my_scope][:extends]).to eq([:foo, :bar])
+        end
+      end
+    end
+  end
+end

data/spec/model_view/resolver_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'pry'
+
+describe ModelView::Resolver do
+  let(:scopes) do
+    {
+      __root__: {
+        fields: {
+          field1: {},
+          field2: {},
+          field3: {}
+        },
+      },
+      scope1: {
+        fields: {
+          field4: {block: Proc.new { |obj| obj.field4 + obj.field1 }},
+          field5: {},
+          field6: {}
+        },
+      },
+      scope2: {
+        extends: [:scope1],
+        fields: {
+          field7: {block: Proc.new { |obj, counter| obj.field7 + counter}, args: {context: [:my_counter]}},
+          field8: {},
+          field9: {}
+        },
+      },
+      scope3: {
+        includes: [:scope1],
+        fields: {
+          field10: {},
+          field11: {},
+          field12: {}
+        },
+      }
+    }
+  end
+
+  describe :fields_for_scope do
+
+    context "on the root scope" do
+      it "returns the root-level fields" do
+        result = ModelView::Resolver.fields_for_scope(ModelView::ROOT, scopes)
+
+        expect(result.keys).to include(*[:field1, :field2, :field3])
+      end
+    end
+
+    context "on a scope" do
+      it "returns the root-level fields and the scope fields" do
+        result = ModelView::Resolver.fields_for_scope(:scope1, scopes)
+
+        expect(result.keys).to include(*[:field1, :field2, :field3, :field4, :field5, :field6])
+      end
+    end
+
+    context "on a scope extending another scope" do
+      it "also includes the extended scope's fields" do
+        result = ModelView::Resolver.fields_for_scope(:scope2, scopes)
+
+        expect(result.keys).to include(*[:field1, :field2, :field3, :field4, :field5, :field6, :field7, :field8, :field9])
+      end
+    end
+
+    context "on a scope including another scope" do
+      it "includes the includes scope's fields under a namespace" do
+        result = ModelView::Resolver.fields_for_scope(:scope3, scopes)
+
+        expect(result.keys).to include(*[:field1, :field2, :field3, :field10, :field11, :field12, :scope1])
+        expect(result[:scope1].keys).to include(*[:field1, :field2, :field3, :field4, :field5, :field6])
+      end
+    end
+
+  end
+
+  describe :resolve do
+    before do
+      class Dummy
+        def field1() 1 end
+        def field2() 2 end
+        def field3() 3 end
+        def field4() 4 end
+        def field5() 5 end
+        def field6() 6 end
+        def field7() 7 end
+        def field8() 8 end
+        def field9() 9 end
+        def field10() 10 end
+        def field11() 11 end
+        def field12() 12 end
+      end
+    end
+
+    let(:instance) { Dummy.new }
+
+    context "for the root scope" do
+      it "returns the resolved root-scope fields" do
+        res = ModelView::Resolver.resolve(instance, scopes)
+        expect(res).to eq({field1: 1, field2: 2, field3: 3})
+      end
+    end
+
+    context "fields with a block" do
+      context "with an arity of one" do
+        it "evaluates the block" do
+          res = ModelView::Resolver.resolve(instance, scopes, :scope1)
+          expect(res[:field4]).to eq(5)
+        end
+      end
+
+      context "with an arity greater than one" do
+        context "no context specified in the field arguments" do
+          it "foo"
+
+        end
+
+        context "no a context specified in the field arguments" do
+          let(:dummy_context) { {foo: 1, bar: 2, my_counter: 100} }
+          it "injects the context into the proc" do
+            res = ModelView::Resolver.resolve(instance, scopes, :scope2, dummy_context)
+            expect(res[:field7]).to eq(107)
+          end
+        end
+
+        it "evaluates the block" do
+          res = ModelView::Resolver.resolve(instance, scopes, :scope1)
+          expect(res[:field4]).to eq(5)
+        end
+      end
+    end
+
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'model_view'
+require 'pry'
+
+RSpec.configure do |config|
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: model_view
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Martin Pretorius
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -82,15 +82,26 @@ dependencies:
         version: '0.10'
 description: Composable serialisation for models
 email:
+- martin@offerzen.com
 - glasnoster@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gem_server"
 - ".gitignore"
+- CHANGELOG.md
+- Gemfile
 - LICENSE
 - README.md
-homepage: http://rubygems.org/gems/model_view
+- lib/model_view.rb
+- lib/model_view/resolver.rb
+- lib/model_view/version.rb
+- model_view.gemspec
+- spec/model_view/model_view_spec.rb
+- spec/model_view/resolver_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Offerzen/model_view
 licenses:
 - MIT
 metadata: {}
@@ -114,4 +125,7 @@ rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Composable serialisation for models
-test_files: []
+test_files:
+- spec/model_view/model_view_spec.rb
+- spec/model_view/resolver_spec.rb
+- spec/spec_helper.rb