lazy_lazer 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77feb46739d312dbc726ab9291c19b7d1d585a44
-  data.tar.gz: a9a5ffda84ee0ed882b7944d7a7767e59d8efeb9
+  metadata.gz: 55bf334bce0c909389956b65961ebb47509dc3bf
+  data.tar.gz: d13f32962f1218f44213c5221488396c2a3de4a5
 SHA512:
-  metadata.gz: 8c4ec41ef8145e740c889200494831016cbb543f3fe1231bc93105a477bedcb765c242abc78f3307fabf8e791692da9a071b1dd991056c552c84ea2a216bffbf
-  data.tar.gz: e067e5cd6cde812fd9731b02ba4a4e5ee98a6a3bd630ae2241ef5d1f35f4d933ab526143b5acb77801deae4e5e5ae16067b9f7f062e12f41e875d3f56085e8ec
+  metadata.gz: 48988bc8b686edf6080fc1468d09ac7385cd77eefec05a7d370657d7248e02ce125c4546cae6940f201dc5349e6235783f4020c8a2c35de800ee616e3428de80
+  data.tar.gz: e212429d02a6b1de380196d92fab5a79097c32032b9e9fa86edef7e3c4d4fe5a94b5e168ef46c512f92dc86575dc393ea02dc7f66e20db4059c764f9da996ede

data/README.md

@@ -15,13 +15,17 @@ class User
   property :twitter_handle, :nil
   property :favorite_ice_cream
 
-  def try_another_flavor!
+  def say_flavor!
     if exists_locally?(:favorite_ice_cream)
       puts "#{name} currently likes #{favorite_ice_cream}."
     else
       puts "#{name} doesn't have a favorite ice cream flavor yet."
     end
-    invalidate(:favorite_ice_cream)
+  end
+
+  def try_another_flavor!
+    delete_attribute(:favorite_ice_cream)
+    not_fully_loaded!
     puts "#{name} just tried #{favorite_ice_cream}. They love it!"
   end
 
@@ -35,7 +39,7 @@ end
 
 user = User.new(name: 'Blinky', creation_time_utc: 1500000000, age: '21')
 
-user.name             #=> 'Blinky'
+user.name           #=> "Blinky"
 user.email          #=> "unknown@example.com"
 user.created_at     #=> 2017-07-14 03:40:00 +0100
 user.age            #=> 21
@@ -45,9 +49,8 @@ user.favorite_ice_cream         #=> "chocolate"
 user.favorite_ice_cream         #=> "chocolate"
 user.reload.favorite_ice_cream  #=> "vanilla"
 
-user.try_another_flavor!
-#=> Blinky currently likes vanilla.
-#=> Blinky just tried strawberry. They love it!
+user.say_flavor!         #=> Blinky currently likes vanilla.
+user.try_another_flavor! #=> Blinky just tried strawberry. They love it!
 ```
 
 <p align="center">

data/lib/lazy_lazer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 require_relative 'lazy_lazer/errors'
 require_relative 'lazy_lazer/internal_model'
 require_relative 'lazy_lazer/key_metadata_store'
@@ -62,8 +64,10 @@ module LazyLazer
   module InstanceMethods
     extend Forwardable
 
-    def_delegators :@_lazer_model, :to_h, :inspect, :read_attribute, :write_attribute, :fully_loaded?, :fully_loaded!, :not_fully_loaded!, :invalidate, :exists_locally?
-    private :fully_loaded!, :not_fully_loaded!, :invalidate, :exists_locally?
+    def_delegators :@_lazer_model,
+                   :to_h, :inspect, :read_attribute, :write_attribute, :delete_attribute,
+                   :fully_loaded?, :fully_loaded!, :not_fully_loaded!, :exists_locally?
+    private :fully_loaded!, :not_fully_loaded!, :exists_locally?
 
     # Create a new instance of the class from a set of source attributes.
     # @param attributes [Hash] the model attributes

data/lib/lazy_lazer/internal_model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module LazyLazer
   # A delegator for internal operations.
   class InternalModel
@@ -9,39 +11,35 @@ module LazyLazer
     def initialize(key_metadata, parent)
       @key_metadata = key_metadata
       @parent = parent
-      @invalidated = Set.new
-      @source_hash = {}
-      @cache_hash = {}
+      @cache = {}
+      @source = {}
+      @writethrough = {}
       @fully_loaded = false
     end
 
     # Converts all unconverted keys and packages them as a hash.
     # @return [Hash] the converted hash
-    def to_h
-      return @cache_hash if fully_loaded?
-      todo = @key_metadata.keys - @cache_hash.keys
-      todo.each_with_object(@cache_hash) { |key, cache| cache[key] = load_key_from_source(key) }.dup
+    def to_h(strict: false)
+      todo = @key_metadata.keys - @cache.keys
+      todo.each do |key|
+        strict ? load_key_strict(key) : load_key_lenient(key)
+      end
+      @cache.dup
     end
 
     # @return [String] the string representation of the parent
     def inspect
       "#<#{@parent.class.name} (#{@fully_loaded ? 'loaded' : 'unloaded'}): [" + \
-        @cache_hash.keys.join(', ') + ']>'
+        @cache.keys.join(', ') + ']>'
     end
 
     # Whether the key doesn't need to be lazily loaded.
     # @param key_name [Symbol] the key to check
     # @return [Boolean] whether the key exists locally.
     def exists_locally?(key_name)
+      return true if @cache.key?(key_name) || @writethrough.key?(key_name)
       meta = ensure_metadata_exists(key_name)
-      @source_hash.key?(meta.source_key)
-    end
-
-    # Mark a key as tainted, forcing a reload on the next lookup.
-    # @param key_name [Symbol] the key to invalidate
-    # @return [void]
-    def invalidate(key_name)
-      @invalidated.add(key_name)
+      @source.key?(meta.source_key)
     end
 
     # Get the value of a key (fetching it from the cache if possible)
@@ -49,12 +47,7 @@ module LazyLazer
     # @return [Object] the returned value
     # @raise MissingAttribute if the attribute wasn't found and there isn't a default
     def read_attribute(key_name)
-      key_name_sym = key_name.to_sym
-      if @invalidated.include?(key_name_sym)
-        @parent.reload
-        @invalidated.delete(key_name_sym)
-      end
-      @cache_hash[key_name_sym] ||= load_key_from_source(key_name_sym)
+      @cache.fetch(key_name) { load_key_strict(key_name) }
     end
 
     # Update an attribute.
@@ -62,10 +55,21 @@ module LazyLazer
     # @param new_value [Object] the new value
     # @return [Object] the written value
     def write_attribute(key_name, new_value)
-      unless @key_metadata.contains?(key_name)
-        raise ArgumentError, "#{key_name} is not a valid attribute for #{parent}"
-      end
-      @cache_hash[key_name] = new_value
+      meta = ensure_metadata_exists(key_name)
+      @source.delete(meta.source_key)
+      @writethrough[key_name] = @cache[key_name] = new_value
+    end
+
+    # Delete an attribute
+    # @param key_name [Symbol] the name of the key
+    # @return [void]
+    def delete_attribute(key_name)
+      key_name_sym = key_name.to_sym
+      meta = ensure_metadata_exists(key_name_sym)
+      @cache.delete(key_name)
+      @writethrough.delete(key_name)
+      @source.delete(meta.source_key)
+      nil
     end
 
     # Mark the model as fully loaded.
@@ -91,7 +95,7 @@ module LazyLazer
     # @return [void]
     def verify_required!
       @key_metadata.required_properties.each do |key_name|
-        next if @source_hash.key?(@key_metadata.get(key_name).source_key)
+        next if @source.key?(@key_metadata.get(key_name).source_key)
         raise RequiredAttribute, "#{@parent} requires `#{key_name}`"
       end
     end
@@ -106,8 +110,8 @@ module LazyLazer
     # @api private
     # @param attributes [Hash<Symbol, Object>] the attributes to merge
     def merge!(attributes)
-      @cache_hash.clear
-      @source_hash.merge!(attributes)
+      @cache.clear
+      @source.merge!(attributes)
     end
 
     private
@@ -116,11 +120,36 @@ module LazyLazer
     # @param key_name [Symbol] the key name
     # @return [Object] the returned value
     # @raise MissingAttribute if the attribute wasn't found and there isn't a default
-    def load_key_from_source(key_name)
+    def load_key_strict(key_name)
       meta = ensure_metadata_exists(key_name)
-      ensure_key_is_loaded(meta.source_key, meta.runtime_required?)
-      return fetch_default(meta.default) unless @source_hash.key?(meta.source_key)
-      transform_value(@source_hash[meta.source_key], meta.transform)
+      reload_if_missing(key_name, meta.source_key)
+      if !exists_locally?(key_name) && !meta.default_provided?
+        raise MissingAttribute, "`#{meta.source_key} is missing for #{@parent}`"
+      end
+      parse_key(meta, key_name)
+    end
+
+    # Load the key and apply transformations to it, skipping the cache.
+    # @param key_name [Symbol] the key name
+    # @return [Object] the returned value
+    def load_key_lenient(key_name)
+      meta = ensure_metadata_exists(key_name)
+      reload_if_missing(key_name, meta.source_key)
+      parse_key(meta, key_name)
+    end
+
+    def reload_if_missing(key_name, source_key)
+      @parent.reload if !@writethrough.key?(key_name) && !@source.key?(source_key) && !@fully_loaded
+    end
+
+    def parse_key(meta, key_name)
+      if @source.key?(meta.source_key)
+        @cache[key_name] = transform_value(@source[meta.source_key], meta.transform)
+      elsif @writethrough.key?(key_name)
+        @cache[key_name] = @writethrough[key_name]
+      elsif meta.default_provided?
+        @cache[key_name] = fetch_default(meta.default)
+      end
     end
 
     # Ensure the metadata is found.
@@ -132,17 +161,6 @@ module LazyLazer
       raise MissingAttribute, "`#{key_name}` isn't defined for #{@parent}"
     end
 
-    # Reloads the model if a key isn't loaded and possibly errors if the key still isn't there.
-    # @param source_key [Symbol] the key that should be loaded
-    # @param runtime_required [Boolean] whether to raise an error if the key is not loaded
-    # @return [void]
-    # @raise MissingAttribute if runtime_required is true and the key can't be loaded.
-    def ensure_key_is_loaded(source_key, runtime_required)
-      @parent.reload if !@source_hash.key?(source_key) && !@fully_loaded
-      return if @source_hash.key?(source_key) || !runtime_required
-      raise MissingAttribute, "`#{source_key} is missing for #{@parent}`"
-    end
-
     # Apply a transformation to a value.
     # @param value [Object] a value
     # @param transform [nil, Proc, Symbol] a transform type

data/lib/lazy_lazer/key_metadata.rb

@@ -11,8 +11,8 @@ module LazyLazer
     # @return [Boolean] whether the key must exist when creating the model
     attr_writer :required
 
-    # @return [Boolean] whether the key must exist when loaded
-    attr_writer :runtime_required
+    # @return [Boolean] whether a default was provided
+    attr_writer :default_provided
 
     # @return [Proc, Object] the default value or generator
     attr_accessor :default
@@ -26,7 +26,7 @@ module LazyLazer
       boolean_options.each_with_object(options) { |sym, hsh| hsh[sym] = true }
       self.source_key = options[:from] || key_name
       self.required = !!options[:required]
-      self.runtime_required = !options.key?(:default) && !options[:nil]
+      self.default_provided = options.key?(:default) || options[:nil]
       self.transform = options[:with]
       self.default = options[:default]
     end
@@ -36,9 +36,9 @@ module LazyLazer
       @required
     end
 
-    # @return [Boolean] whether the key must exist when loaded
-    def runtime_required?
-      @runtime_required
+    # @return [Boolean] whether no default was provided
+    def default_provided?
+      @default_provided
     end
   end
 end

data/lib/lazy_lazer/version.rb

@@ -2,5 +2,5 @@
 
 module LazyLazer
   # The gem's semantic version number.
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_lazer
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Avinash Dwarapu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-02 00:00:00.000000000 Z
+date: 2017-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler