lazy_lazer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60a5387afe075f801b80682c550567d99da5a88e
-  data.tar.gz: 39ebc9c0c59e3b5010d2e6d1e5dca543c2f0a494
+  metadata.gz: a24047c46cd370e8fb1d092129dacb1816f50ebc
+  data.tar.gz: 072b5a1b15857682e4317eb8f275685462199e3e
 SHA512:
-  metadata.gz: 2726ff1abd8149b613a7cc6a689d4a1c3cf3e4f67924d59af9b02cac6186afc1a6de256498ea0edcff9e427303f1d6188eb672d222ced672d4b432d928c2ebc2
-  data.tar.gz: c26457eb59bef476eac2c5de64c84a041bddfd212e40bfa901e7adb13dc22c578f76e3c9d79be89c1da1c4e97f5a4941632e0d180290985c619976ff425c6573
+  metadata.gz: de1fb716edf702586d593c085256d984ee3bd8cf0be8811381ac1d6eec10451146fa16f0e88f89a9561ad54d2242a255fc5351c1c6f0d961a2b01dc0e1c62f2d
+  data.tar.gz: ada536d3a04d7ce62beff22a4e2afb1d1cf38bf1aa51cae3f08e1e2bed9f2848cecb42b5af8d047c4cea6a2260864749ee9ac5975748f525bbc51c72f29749c8

data/.rubocop.yml

@@ -20,3 +20,5 @@ Metrics/CyclomaticComplexity:
   Severity: refactor
 Metrics/PerceivedComplexity:
   Severity: refactor
+Metrics/MethodLength:
+  Severity: refactor

data/README.md

@@ -1,7 +1,7 @@
 **lazy lazer**
 
 **features**:
-- simple codebase (~100 lines of code)
+- simple codebase (~110 lines of code, ~200 lines of tests)
 - doesn't inherit all of the Hash and Enumerable cruft
 - super lazy, doesn't even parse attributes until it's necessary
 
@@ -9,35 +9,26 @@
 class User
   include LazyLazer
 
-  # User.new(first_name: 'John')  #=> Error: missing `id`
-  # User.new(id: 1).id?  #=> true
   property :id, required: true
-
-  # user = User.new(id: 1)
-  # user.email  #=> nil
-  property :email, default: nil
-
-  # user = User.new(id: 1)
-  # user.language  #=> :en_US
-  property :language, default: :en_US
-
-  # user = User.new(id: 1, first_name: 'John')
-  # user.name  #=> 'John'
-  # user.first_name  #=> NoMethodError: ...
-  property :last_name, default: -> { %w[Doe Bloggs Hansen].sample }
-
-  # user = User.new(id: 1, created_at: 1502834161)
-  # user.created_at  #=> 2017-08-15 22:56:13 +0100
-  property :created_at, with: ->(time) { Time.at(time) }
-
-  # user = User.new(id: 1, age: '45')
-  # user.age  #=> 45
+  property :email, default: 'unknown@example.com'
+  property :created_at, from: 'creation_time_utc', with: ->(time) { Time.at(time) }
   property :age, with: :to_i
 
-  def reload
-    update_attributes!(email: "#{last_name}@gmail.com") # update your attributes
+  property :favorite_ice_cream
+
+  def lazer_reload
     self.fully_loaded = true # mark model as fully updated
-    self # a rails convention, totally optional
+    { favorite_ice_cream: %w[vanilla strawberry chocolate].sample }
   end
 end
+
+user = User.new(id: 152, creation_time_utc: 1500000000, age: '21')
+
+user.id          #=> 152
+user.email       #=> "unknown@example.com"
+user.created_at  #=> 2017-07-14 03:40:00 +0100
+user.age         #=> 21
+
+user.favorite_ice_cream         #=> "chocolate"
+user.reload.favorite_ice_cream  #=> "vanilla"
 ```

data/lib/lazy_lazer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyLazer
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/lazy_lazer.rb

@@ -2,9 +2,8 @@
 
 require_relative 'lazy_lazer/version'
 require_relative 'lazy_lazer/errors'
-require_relative 'lazy_lazer/utilities'
 
-# LazyLazer is a lazy loading model.
+# LazyLazer
 module LazyLazer
   # Hook into `include LazyLazer`.
   # @param [Module] base the object to include the methods in
@@ -12,8 +11,22 @@ module LazyLazer
   def self.included(base)
     base.extend(ClassMethods)
     base.include(InstanceMethods)
-    base.instance_variable_set(:@_lazer_properties, {})
-    base.instance_variable_set(:@_lazer_required_properties, [])
+    base.instance_variable_set(
+      :@lazer_metadata,
+      properties: [],
+      required: {},
+      default: {},
+      from: {},
+      with: {}
+    )
+  end
+
+  # Get the source key from an instance
+  # @param [Object] instance the instance
+  # @param [Symbol] key the property key
+  # @return [Symbol] the source key if found or the passed key if not found
+  def self.source_key(instance, key)
+    instance.class.lazer_metadata[:from].fetch(key, key)
   end
 
   # The methods to extend the class with.
@@ -22,78 +35,118 @@ module LazyLazer
     # @param [Class] klass the subclass
     # @return [void]
     def inherited(klass)
-      klass.instance_variable_set(:@_lazer_properties, @_lazer_properties)
-      klass.instance_variable_set(:@_lazer_required_properties, @_lazer_required_properties)
+      klass.instance_variable_set(:@lazer_metadata, @lazer_metadata)
     end
 
-    # @return [Hash<Symbol, Hash>] defined properties and their options
-    def properties
-      @_lazer_properties
+    # @return [Hash<Symbol, Hash>] the lazer configuration for this model
+    def lazer_metadata
+      @lazer_metadata
     end
 
     # Define a property.
     # @param [Symbol] name the name of the property method
     # @param [Hash] options the options to create the property with
-    # @option options [Boolean] :required (false) whether existence of this
-    #   property should be checked on model creation
-    # @option options [Symbol, Array<Symbol>] :from (name) the key(s) to get
-    #   the value of the property from
-    # @option options [Object, Proc] :default the default value to return if
-    #   not provided
-    # @option options [Proc, Symbol] :with an optional transformation to apply
-    #   to the value of the key
+    # @option options [Boolean] :required (false) whether existence of this property should be
+    #   checked on model creation
+    # @option options [Object, Proc] :default the default value to return if not provided
+    # @option options [Symbol] :from the key in the source object to get the property from
+    # @option options [Proc, Symbol] :with an optional transformation to apply to the value
+    # @note both :required and :default can't be provided
+    # @return [Symbol] the name of the created property
     def property(name, **options)
+      raise 'both :required and :default cannot be given' if options[:required] && options[:default]
       sym_name = name.to_sym
-      properties[sym_name] = options
-      @_lazer_required_properties << sym_name if options[:required]
-      define_method(name) { read_attribute(name) }
+      @lazer_metadata[:properties] << sym_name
+      options.each_pair { |option, value| @lazer_metadata[option][sym_name] = value }
+      define_method(sym_name) { read_attribute(sym_name) }
     end
   end
 
-  # The base model class. This could be included directly.
+  # The methods to extend the instance with.
   module InstanceMethods
-    # Initializer.
-    #
+    # Create a new instance of the class from a set of source attributes.
     # @param [Hash] attributes the model attributes
     # @return [void]
     def initialize(attributes = {})
-      # Check all required attributes.
-      self.class.instance_variable_get(:@_lazer_required_properties).each do |prop|
-        raise RequiredAttribute, "#{self} requires `#{prop}`" unless attributes.key?(prop)
+      # Check that all required attributes exist.
+      self.class.lazer_metadata[:required].keys.each do |property|
+        key = LazyLazer.source_key(self, property)
+        raise RequiredAttribute, "#{self} requires `#{key}`" unless attributes.key?(key)
       end
 
-      @_lazer_attribute_source = attributes.dup
-      @_lazer_attribute_cache = {}
+      @_lazer_source = attributes.dup
+      @_lazer_cache = {}
     end
 
+    # Converts all the attributes that haven't been converted yet and returns the final hash.
     # @param [Boolean] strict whether to fully load all attributes
     # @return [Hash] a hash representation of the model
     def to_h(strict = true)
       if strict
-        remaining = @_lazer_attribute_source.keys - @_lazer_attribute_cache.keys
-        remaining.each do |key|
-          @_lazer_attribute_cache[key] = read_attribute(key)
-        end
+        todo = self.class.lazer_metadata[:properties] - @_lazer_cache.keys
+        todo.each { |k| read_attribute(k) }
       end
-      @_lazer_attribute_cache
+      @_lazer_cache
     end
 
-    # Reload the object.
-    def reload; end
+    # @abstract Provides reloading behaviour for lazy loading.
+    # @return [Hash] the result of reloading the hash
+    # @note if necessary, subclasses can make this method private, so this isn't tested.
+    def lazer_reload
+      self.fully_loaded = true
+      {}
+    end
+
+    # Reload the object. Calls {#lazer_reload}, then merges the results into the internal store.
+    # Also evicts the internal cache of the new keys.
+    # @return [self] the updated object
+    def reload
+      new_attributes = lazer_reload
+      @_lazer_source.merge!(new_attributes)
+      @_lazer_cache = {}
+      self
+    end
 
     # Return the value of the attribute.
     # @param [Symbol] name the attribute name
     # @raise MissingAttribute if the key was not found
     def read_attribute(name)
-      return @_lazer_attribute_cache[name] if @_lazer_attribute_cache.key?(name)
-      reload if self.class.properties.key?(name) && !fully_loaded?
-      options = self.class.properties.fetch(name, {})
+      # Returns the cached attribute.
+      return @_lazer_cache[name] if @_lazer_cache.key?(name)
+
+      # Converts the property into the lookup key.
+      source_key = LazyLazer.source_key(self, name)
 
-      if !@_lazer_attribute_source.key?(name) && !options.key?(:default)
-        raise MissingAttribute, "#{name} is missing for #{self}"
+      # Reloads if a key that should be there isn't.
+      reload if !@_lazer_source.key?(source_key) &&
+                self.class.lazer_metadata[:required].include?(name) &&
+                !fully_loaded?
+
+      # Complains if even after reloading, the key is missing (and there's no default).
+      if !@_lazer_source.key?(source_key) && !self.class.lazer_metadata[:default].key?(name)
+        raise MissingAttribute, "`#{source_key}` missing for #{self}"
+      end
+
+      # Gets the value or gets the default.
+      value_or_default = @_lazer_source.fetch(source_key) do
+        default = self.class.lazer_metadata[:default][name]
+        default.is_a?(Proc) ? instance_exec(&default) : default
       end
-      uncoerced = Utilities.lookup_default(@_lazer_attribute_source, name, options[:default])
-      Utilities.transform_value(uncoerced, options[:with])
+
+      # Transforms the result using :with, if found.
+      transformer = self.class.lazer_metadata[:with][name]
+      coerced =
+        case transformer
+        when Symbol
+          value_or_default.public_send(transformer)
+        when Proc
+          instance_exec(value_or_default, &transformer)
+        else
+          value_or_default
+        end
+
+      # Add to cache and return the result.
+      @_lazer_cache[name] = coerced
     end
 
     # Return the value of the attribute, returning nil if not found
@@ -108,7 +161,7 @@ module LazyLazer
     # @param [Symbol] attribute the attribute to update
     # @param [Object] value the new value
     def write_attribute(attribute, value)
-      @_lazer_attribute_cache[attribute] = value
+      @_lazer_cache[attribute] = value
     end
 
     # Update multiple attributes at once.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_lazer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Avinash Dwarapu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -130,7 +130,6 @@ files:
 - lazy_lazer.gemspec
 - lib/lazy_lazer.rb
 - lib/lazy_lazer/errors.rb
-- lib/lazy_lazer/utilities.rb
 - lib/lazy_lazer/version.rb
 homepage: https://github.com/avinashbot/lazy_lazer
 licenses:

data/lib/lazy_lazer/utilities.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module LazyLazer
-  # Utility methods.
-  # @api private
-  module Utilities
-    # Get a value from a hash, calling the default if needed.
-    # @param [Hash] source the hash to lookup
-    # @param [Symbol] key the key to lookup
-    # @param [Proc, Object] default the default value or Proc to call
-    # @return the object or the default value
-    def self.lookup_default(source, key, default)
-      return source[key] if source.key?(key)
-      return default.call if default.is_a?(Proc)
-      default
-    end
-
-    # Transforms a value using a "transformer" supplied using :with.
-    # @param [Object] value the value to transform
-    # @param [nil, Symbol, Proc] transformer the transformation method
-    # @param [Object] context the context to run the proc in
-    # @return [Object] the result of applying the transformation to the value
-    def self.transform_value(value, transformer)
-      case transformer
-      when nil
-        value
-      when Symbol
-        value.public_send(transformer)
-      when Proc
-        transformer.call(value)
-      end
-    end
-  end
-end