tarvit-helpers 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 047b0913876d901d412a7e7cc11216c66ebcf892
-  data.tar.gz: e8818a9f0f1bf8f0eff4f583760768e0b2311889
+  metadata.gz: 5f2117e675264e10c3128bff56b480e423672048
+  data.tar.gz: cd965580ba89f6982bb98f6c12a3ef97cd217e1a
 SHA512:
-  metadata.gz: 9ee9af47dc6705145a2b9cd5cf13eaa603506b64851e3afa92c2345b921153c9d893686444b26297b697df46c3cf58b621412c918a7e69042949945bf804a1c8
-  data.tar.gz: 800b7f04ca01b573eeb069ce030f649a7aa7a5728dc184c1d321da133172420869ce66ac012faa337307a2d2c1bb4375b45fc4185c5386c295bb19595f33c5c4
+  metadata.gz: 66f741c836965bf736ae7eada042a3f554574d1fb1ee4eef693261cb903af73b6d688e6081bd7c40dfe55520af370533a499605c7f5691248d21bfdb52799340
+  data.tar.gz: ba134f8d4ae9e358c32dfac59db198548540aaffeb46428df06df9777ebabf925808f37f7c72544c91f9d9e715ad0221b3e97de6e6480ed2f1f9cb0d0da45cba

data/VERSION

@@ -1 +1 @@
-0.0.10
+0.0.11

data/lib/tarvit-helpers/modules/hash_presenter.rb

@@ -1,44 +1,81 @@
 module TarvitHelpers
-  class HashPresenter
-    require 'active_support/core_ext/string'
+  module HashPresenter
 
-    attr_reader :hash
-
-    def initialize(hash)
-      @hash = prepare_keys(hash)
+    def self.present(hash, option = :cached )
+      raise ArgumentError.new("#{ hash.class } is not a Hash") unless hash.is_a?(Hash)
+      factory[option].new(hash)
     end
 
-    def method_missing(m, *args)
-      return value(m) if accessor_method?(m)
-      super
+    def self.factory
+      { cached: CachedHashPresenter, observable: ObservableHashPresenter }
     end
 
-    protected
+    class SimpleHashPresenter
+      require 'active_support/core_ext/string'
 
-    def value(method_name)
-      res = @hash[method_name]
-      transform_value(res)
-    end
+      attr_reader :hash
 
-    def transform_value(x)
-      return x.map{|x| transform_value(x) } if x.is_a?(Array)
-      x.is_a?(Hash) ? self.class.new(x) : x
-    end
+      def initialize(hash)
+        @hash = prepare_keys(hash)
+      end
+
+      def method_missing(m, *args)
+        return value(m) if accessor_method?(m)
+        super
+      end
+
+      protected
+
+      def value(method_name)
+        res = self.hash[method_name]
+        transform_value(res)
+      end
+
+      def transform_value(x)
+        return x.map{|x| transform_value(x) } if x.is_a?(Array)
+        x.is_a?(Hash) ? self.class.new(x) : x
+      end
+
+      def accessor_method?(method_name)
+        self.hash.keys.include?(method_name)
+      end
+
+      def key_to_method(key)
+        key.to_s.gsub(/\s+/, ?_).underscore.to_sym
+      end
+
+      def prepare_keys(hash)
+        res = hash.map do |k ,v|
+          [ key_to_method(k), v ]
+        end
+        Hash[res]
+      end
 
-    def accessor_method?(method_name)
-      @hash.keys.include?(method_name)
     end
 
-    def key_to_method(key)
-      key.to_s.gsub(/\s+/, ?_).underscore.to_sym
+    class CachedHashPresenter < SimpleHashPresenter
+
+      def initialize(hash)
+        super
+        @cache = {}
+      end
+
+      def value(method_name)
+        @cache[method_name] ||= super
+      end
+
     end
 
-    def prepare_keys(hash)
-      res = hash.map do |k ,v|
-        [ key_to_method(k), v ]
+    class ObservableHashPresenter < SimpleHashPresenter
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def hash
+        prepare_keys(@hash)
       end
-      Hash[res]
     end
 
   end
 end
+

data/spec/modules/hash_presenter_spec.rb

@@ -1,32 +1,144 @@
 require 'spec_helper'
 
+module BaseHashPresenterTest
+
+  def test_presenter(hash_presenter)
+
+    it 'should present a flat hash' do
+      hp = hash_presenter.new(a: 1, b: 2, 'c' => [ 3 ] )
+      expect(hp.a).to eq(1)
+      expect(hp.b).to eq(2)
+      expect(hp.c).to eq([ 3 ])
+      expect(->{ hp.d }).to raise_error(NoMethodError)
+    end
+
+    it 'should transform complex keys' do
+      hp = hash_presenter.new('A very big key' => :value)
+      expect(hp.a_very_big_key).to eq(:value)
+    end
+
+    it 'should present nested hashes' do
+      hp = hash_presenter.new(a: { b: 1, c: { d: 2 } })
+      expect(hp.a).to be_a(hash_presenter)
+      expect(hp.a.b).to eq(1)
+      expect(hp.a.c.d).to eq(2)
+    end
+
+    it 'should present arrays with hashes' do
+      hp = hash_presenter.new(a: [ { b: 1 }, { c: 2 }, 3 ])
+      expect(hp.a[0].b).to eq(1)
+      expect(hp.a[1].c).to eq(2)
+      expect(hp.a[2]).to eq(3)
+    end
+  end
+end
+
+describe HashPresenter::SimpleHashPresenter do
+
+  extend BaseHashPresenterTest
+  test_presenter(HashPresenter::SimpleHashPresenter)
+
+  context 'Special Behavior' do
+
+    it 'should not depend on an attribute object' do
+      original = { a: 2 }
+      hp = HashPresenter::SimpleHashPresenter.new(original)
+
+      expect(hp.a).to eq(2)
+
+      original[:a] = 3
+
+      expect(hp.a).to eq(2)
+    end
+
+    it 'should regenerate method result for a nested hash' do
+      hp = HashPresenter::SimpleHashPresenter.new(a: { b: 1 })
+      expect(hp.a.object_id).to_not eq(hp.a.object_id)
+    end
+  end
+end
+
+describe HashPresenter::CachedHashPresenter do
+
+  extend BaseHashPresenterTest
+  test_presenter(HashPresenter::CachedHashPresenter)
+
+  context 'Special Behavior' do
+
+    it 'should not depend on an attribute object' do
+      original = { a: 2 }
+      hp = HashPresenter::CachedHashPresenter.new(original)
+
+      expect(hp.a).to eq(2)
+
+      original[:a] = 3
+
+      expect(hp.a).to eq(2)
+    end
+
+    it 'should not calculate result for a nested hash twice' do
+      hp = HashPresenter::CachedHashPresenter.new(a: { b: 1 })
+      expect(hp.a.object_id).to eq(hp.a.object_id)
+    end
+  end
+end
+
+
+describe HashPresenter::ObservableHashPresenter do
+
+  extend BaseHashPresenterTest
+  test_presenter(HashPresenter::ObservableHashPresenter)
+
+  context 'Special Behavior' do
+
+    it 'should observe an attribute object' do
+      original = { a: 2 }
+      hp = HashPresenter::ObservableHashPresenter.new(original)
+
+      expect(hp.a).to eq(2)
+
+      original[:a] = 3
+
+      expect(hp.a).to eq(3)
+
+      original[:a] = { b: 1 }
+
+      expect(hp.a.b).to eq(1)
+
+      original[:c] = 4
+
+      expect(hp.c).to eq(4)
+    end
+
+    it 'should regenerate method result for a nested hash' do
+      hp = HashPresenter::ObservableHashPresenter.new(a: { b: 1 })
+      expect(hp.a.object_id).to_not eq(hp.a.object_id)
+    end
+  end
+end
+
 describe HashPresenter do
 
-  it 'should present a flat hash' do
-    hp = HashPresenter.new(a: 1, b: 2, 'c' => [ 3 ] )
+  it 'should present hashes' do
+    hp = HashPresenter.present({ a: 1 })
     expect(hp.a).to eq(1)
-    expect(hp.b).to eq(2)
-    expect(hp.c).to eq([ 3 ])
-    expect(->{ hp.d }).to raise_error(NoMethodError)
   end
 
-  it 'should transform complex keys' do
-    hp = HashPresenter.new('A very big key' => :value)
-    expect(hp.a_very_big_key).to eq(:value)
+  it 'should not accept not Hashes' do
+    expect(->{
+      HashPresenter.present('Hash').to raise_error(ArgumentError)
+    })
   end
 
-  it 'should present nested hashes' do
-    hp = HashPresenter.new(a: { b: 1, c: { d: 2 } })
-    expect(hp.a).to be_a(HashPresenter)
-    expect(hp.a.b).to eq(1)
-    expect(hp.a.c.d).to eq(2)
+  it 'should get an observable presenter' do
+    hp = HashPresenter.present({  }, :observable)
+    expect(hp).to be_a(HashPresenter::ObservableHashPresenter)
   end
 
-  it 'should present arrays with hashes' do
-    hp = HashPresenter.new(a: [ { b: 1 }, { c: 2 }, 3 ])
-    expect(hp.a[0].b).to eq(1)
-    expect(hp.a[1].c).to eq(2)
-    expect(hp.a[2]).to eq(3)
+  it 'should get a cached presenter' do
+    hp = HashPresenter.present({  }, :cached)
+    expect(hp).to be_a(HashPresenter::CachedHashPresenter)
   end
 
+
 end

data/tarvit-helpers.gemspec

@@ -2,11 +2,11 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: tarvit-helpers 0.0.10 ruby lib
+# stub: tarvit-helpers 0.0.11 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "tarvit-helpers"
-  s.version = "0.0.10"
+  s.version = "0.0.11"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tarvit-helpers
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Vitaly Tarasenko