lazy_record 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56bce37d54f4018b548f48e32c8605d63bced313
-  data.tar.gz: 1d1df3c2c2285cd238f49ead0d883897c6a8dc2e
+  metadata.gz: fee6bdb6da8c27b811ad1cb292ddaab4d7828f33
+  data.tar.gz: a5b556eea6d24c24baac786eb06b18801cfe1991
 SHA512:
-  metadata.gz: 0acbf3c1895d7bd1501f7f4558dae2f548273eda3052d0b6f2b4a236232ed5db0b6da310c09634ca340a89f44a24192851d729144c067ab54839998ece509ad7
-  data.tar.gz: 96fea24cfc627e8f88d6ca0dd45c8122daaeef7c5aa6ce40ee345ae51d2e7a47866a54f6314b7e853a732853ccb486169c28268ac5f30113e8d02871f1522955
+  metadata.gz: 9fa0cfb63cbe0d972b59442df3f0cd9c5173792ac551109ea0e4be7ba4609f286e1784991c96b96624af442e6dc1972f13e6349f7b5316db5fbeb1347b8ea070
+  data.tar.gz: f0e9a7b71f97167e4fc41ae6874e5bc23b0bdec00f4f119f801ba9e7d0017cae02f9dff719ab4dbd5d487b59752ee6f189a0ce16a7e420d6e26a67f2024323d4

data/README.md

@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.org/msimonborg/lazy_record.svg?branch=master)](https://travis-ci.org/msimonborg/lazy_record)
 [![Coverage Status](https://coveralls.io/repos/github/msimonborg/lazy_record/badge.svg?branch=master)](https://coveralls.io/github/msimonborg/lazy_record?branch=master)
 
-LazyRecord writes a bunch of boilerplate code for your POROs, similarly to what you'd expect ActiveRecord to do for your database-backed objects. This project is an attempt to understand and explore dynamic programming techniques in Ruby, and demystify some of the Rails magic. Maybe someone will find it useful.
+LazyRecord writes a bunch of boilerplate code for your POROs, similarly to what you'd expect ActiveRecord to do for your database-backed objects. The main use case is for working with objects returned by external APIs. This gem can be added as a dependency to your ruby API wrapper to easily enhance your gem's public API. See [PYR](https://github.com/msimonborg/pyr) as an example.
 
 ## Installation
 
@@ -35,7 +35,7 @@ thing = Thing.new { |t| puts t.class.superclass }
 # => #<Thing>
 ```
 
-Alternatively, if you want to inherit from another class, you can mix in the `LazyRecord::BaseModule` and get all the same results.
+Alternatively, if you want to inherit from another class, you can mix in the `LazyRecord::BaseModule` and get all the same features.
 
 ```ruby
 class Thing
@@ -46,7 +46,6 @@ thing = Thing.new { |t| puts t.class.superclass }
 # Object
 # => #<Thing>
 ```
-Every LazyRecord object is assigned an auto-incrementing ID after initialization. IDs reset when the program is terminated.
 
 Use `attr_accessor` like you would use normally, and you'll get hash syntax in your `#intialize` method for attribute setting. The attributes will also be visible when the object is returned or `inspected`. Attributes defined with `attr_reader` will also be visible, but `attr_writers`, custom getters and writers, and other methods will not.
 
@@ -166,7 +165,7 @@ Whatever.low_sleepy
 Whatever.where party_value: 12
 # => #<WhateverRelation [#<Whatever party_value: 12, sleepy_value: 12>
 ```
-You can also use hash syntax and block syntax with `.where`. Block syntax will yield each object in the collection to the block for evaluation.
+You can use hash syntax and block syntax with `.where`. Block syntax acts like `Enumerable#select` and will yield each object in the collection to the block for evaluation.
 ```ruby
 Whatever.where { |w| w.sleepy_value > 5 }
 # => #<WhateverRelation [#<Whatever party_value: 12, sleepy_value: 12>, #<Whatever id: 3, party_value: 4, sleepy_value: 11>]>
@@ -183,7 +182,9 @@ num = 6
 Whatever.where party_value: -> { num * 2 }
 # => #<WhateverRelation [#<Whatever party_value: 12, sleepy_value: 12>]>
 ```
-Use `lr_method` for an alternative API for defining short instance methods using lambda syntax. The first argument passed to the block must be the receiver of the method, or `self` in the method scope.
+Use `lr_method` for an alternative API for defining short instance methods using lambda syntax.
+
+`lr_method` and `lr_scope` work identically except the former is for instance methods and evaluates `self` in the instance scope, while the latter defines class methods and `self` is evaluated in the class scope.
 
 ```ruby
 class Whatever < LazyRecord::Base
@@ -196,8 +197,8 @@ class Thing < LazyRecord::Base
   attr_accessor :stuff, :junk
   lr_validates :stuff, presence: true
   lr_has_many :whatevers
-  lr_method :speak, -> (_x, string) { puts string }
-  lr_method :what_am_i, ->(x) { "I'm a #{x.class}" }
+  lr_method :speak, -> (string) { puts string }
+  lr_method :what_am_i, -> { "I'm a #{self.class}" }
 end
 
 thing = Thing.new stuff: 'stuff'
@@ -210,6 +211,8 @@ thing.what_am_i
 ## Platform support
 
 Tested against:
+* MRI 2.1.0
+* MRI 2.2.2
 * MRI 2.3.0
 * MRI 2.3.4
 * MRI 2.4.1

data/lib/lazy_record.rb

@@ -28,10 +28,10 @@ require 'lazy_record/version'
 require 'lazy_record/associations'
 require 'lazy_record/attributes'
 require 'lazy_record/callbacks'
+require 'lazy_record/class_methods'
 require 'lazy_record/collections'
 require 'lazy_record/dynamic_modules'
 require 'lazy_record/methods'
-require 'lazy_record/nesting'
 require 'lazy_record/scopes'
 require 'lazy_record/validations'
 require 'lazy_record/relation'

data/lib/lazy_record/associations.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require 'lazy_record/nesting'
-
 module LazyRecord
   # Set up in-memory one-to-one associations between POROs.
   module Associations
-    include LazyRecord::Nesting
-
     ASSOCIATION_MODULE_NAME = :Associations
 
     def lr_has_one(*args)
@@ -40,10 +36,10 @@ module LazyRecord
     end
 
     def define_association_setter(assoc)
-      model = find_scoped_association_class(assoc)
+      klass = const_get(assoc.to_s.camelize)
       define_method("#{assoc}=") do |val|
-        return instance_variable_set("@#{assoc}", val) if val.is_a? model.call
-        raise ArgumentError, "Argument must be a #{model.call}"
+        return instance_variable_set("@#{assoc}", val) if val.is_a? klass
+        raise ArgumentError, "Argument must be a #{klass}"
       end
     end
 
@@ -52,9 +48,5 @@ module LazyRecord
         instance_variable_get("@#{association}")
       end
     end
-
-    def find_scoped_association_class(association)
-      -> { apply_nesting(association.to_s.camelize).constantize }
-    end
   end
 end

data/lib/lazy_record/base.rb

@@ -8,6 +8,6 @@ module LazyRecord
   # method generating macros, scope methods and scope chaining, associations
   # with other objects, and validations. This is a WIP still in development.
   class Base
-    include BaseModule
+    include LazyRecord::BaseModule
   end
 end

data/lib/lazy_record/base_module.rb

@@ -4,18 +4,23 @@ module LazyRecord
   # This module gives the Base class its functionality, and can be included
   # in any class as an alternative to inheriting from LazyRecord::Base
   module BaseModule
+    # Modules that compose the functionality of the LazyRecord API
+    LAZY_RECORD_MODULES = [
+      ClassMethods,
+      Scopes,
+      Attributes,
+      Collections,
+      Associations,
+      Callbacks,
+      Validations,
+      Methods,
+      DynamicModules
+    ].freeze
+
     # Extend these modules when BaseModule is included
     def self.included(base)
       base.extend ScopedAttrAccessor
-      base.extend ClassMethods
-      base.extend Scopes
-      base.extend Attributes
-      base.extend Collections
-      base.extend Associations
-      base.extend Callbacks
-      base.extend Validations
-      base.extend Methods
-      base.extend DynamicModules
+      LAZY_RECORD_MODULES.each { |mod| base.extend mod }
     end
 
     # Use options hash to set attributes, and/or operate on object in a block.
@@ -109,42 +114,5 @@ module LazyRecord
             :collection_counts_to_s,
             :associations_to_s,
             :set_equality_conditions
-
-    # Class methods provided to all LazyRecord classes
-    module ClassMethods
-      def public_attr_readers
-        @public_attr_readers ||= attr_readers.reject do |reader|
-          private_method_defined?(reader) || protected_method_defined?(reader)
-        end
-      end
-
-      def attr_readers
-        @attr_readers ||= []
-      end
-
-      def all
-        @all ||= Relation.new(model: self)
-      end
-
-      def count
-        all.count
-      end
-
-      def first
-        all.first
-      end
-
-      def last
-        all.last
-      end
-
-      def where(condition = nil, &block)
-        all.where(condition, &block)
-      end
-
-      def destroy_all
-        all.send(:clear)
-      end
-    end
   end
 end

data/lib/lazy_record/callbacks.rb

@@ -6,7 +6,7 @@ module LazyRecord
   # After #initialize callbacks for validations and setting object id.
   module Callbacks
     def new(opts = {})
-      @all ||= Relation.new(model: self)
+      @all ||= Relation.new(klass: self)
       instance = super(opts)
       if instance.respond_to?(:validation)
         instance = instance.validation(*@validations)

data/lib/lazy_record/class_methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module LazyRecord
+  # Class methods extended to all LazyRecord descendants.
+  module ClassMethods
+    def public_attr_readers
+      @public_attr_readers ||= attr_readers.reject do |reader|
+        private_method_defined?(reader) || protected_method_defined?(reader)
+      end
+    end
+
+    def attr_readers
+      @attr_readers ||= []
+    end
+
+    def all
+      @all ||= Relation.new(klass: self)
+    end
+
+    def count
+      all.count
+    end
+
+    def first
+      all.first
+    end
+
+    def last
+      all.last
+    end
+
+    def where(condition = nil, &block)
+      all.where(condition, &block)
+    end
+
+    def destroy_all
+      all.send(:clear)
+    end
+  end
+end

data/lib/lazy_record/collections.rb

@@ -1,92 +1,109 @@
 # frozen_string_literal: true
 
-require 'lazy_record/nesting'
-
 module LazyRecord
   # Set up in-memory one-to-many relationships between objects
   module Collections
-    include LazyRecord::Nesting
-
     COLLECTION_MODULE_NAME   = :Collections
     NESTED_ATTRS_MODULE_NAME = :NestedAttributes
 
-    def define_collection_getter(collection)
-      model = find_scoped_collection_class(collection)
-      define_method(collection) do
-        if instance_variable_get("@#{collection}").nil?
-          instance_variable_set("@#{collection}", Relation.new(model: model))
+    def _define_collection_getter(collection, options)
+      klass = const_get(options[:class_name])
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{collection}
+          @#{collection} ||= Relation.new(klass: #{klass})
         end
-        instance_variable_get("@#{collection}")
-      end
+      RUBY
     end
 
-    def define_collection_setter(collection)
-      model = find_scoped_collection_class(collection)
-      define_method("#{collection}=") do |coll|
-        coll = Relation.new(model: model, array: coll)
-        instance_variable_set("@#{collection}", coll)
-      end
+    def _define_collection_setter(collection, options)
+      klass = const_get(options[:class_name])
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{collection}=(coll)
+          @#{collection} = Relation.new(klass: #{klass}, collection: coll)
+        end
+      RUBY
     end
 
-    def find_scoped_collection_class(collection)
-      -> { apply_nesting(collection.to_s.classify).constantize }
+    def _define_collection_counter(collection)
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{collection}_count
+          #{collection}.count
+        end
+      RUBY
     end
 
-    def define_collection_counter(collection)
-      define_method("#{collection}_count") do
-        send(collection).count
+    def _add_to_collections(*collections)
+      options = collections.extract_options!
+      collections.each do |collection|
+        class_name = options[:class_name] || collection.to_s.classify
+        _collections[collection.to_sym] = { class_name: class_name }
       end
     end
 
-    def define_collections(*collections)
-      define_method(:collections) do
-        collections
-      end
+    def _collections
+      @_collections ||= {}
     end
 
-    def define_collection_counts_to_s
+    def _define_collection_counts_to_s
       define_method(:collection_counts_to_s) do
-        collections.map do |collection|
+        collections.map do |collection, _options|
           "#{collection}_count: #{stringify_value(send("#{collection}_count"))}"
         end
       end
       private :collection_counts_to_s
     end
 
+    def _define_collections
+      collections = _collections
+      define_method(:collections) { collections }
+    end
+
     def lr_has_many(*collections)
       include mod = get_or_set_mod(COLLECTION_MODULE_NAME)
       mod.extend(Collections)
-      mod.module_eval { add_collection_methods(collections) }
+      mod.module_eval { _add_collection_methods(*collections) }
     end
 
-    def add_collection_methods(collections)
-      define_collections(*collections)
-      define_collection_counts_to_s
-      collections.each do |collection|
-        define_collection_getter(collection)
-        define_collection_setter(collection)
-        define_collection_counter(collection)
+    def _add_collection_methods(*collections)
+      _add_to_collections(*collections)
+      _define_collections
+      _define_collection_counts_to_s
+      _collections.each do |collection, options|
+        _define_collection_getter(collection, options)
+        _define_collection_setter(collection, options)
+        _define_collection_counter(collection)
       end
     end
 
-    def define_collection_attributes_setter(collection, class_name)
-      define_method("#{collection}_attributes=") do |collection_attributes|
-        collection_attributes.values.each do |attributes|
-          send(collection) << class_name.new(attributes)
+    def define_collection_attributes_setter(collection, options)
+      class_name = const_get(options.fetch(:class_name))
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{collection}_attributes=(collection_attributes)
+          collection_attributes.values.each do |attributes|
+            #{collection} << #{class_name}.new(attributes)
+          end
         end
-        collection
-      end
+      RUBY
     end
 
     def lr_accepts_nested_attributes_for(*collections)
-      include mod = get_or_set_mod(NESTED_ATTRS_MODULE_NAME)
+      include mod = get_or_set_mod(COLLECTION_MODULE_NAME)
       mod.extend(Collections)
       mod.module_eval do
         collections.each do |collection|
-          class_name = collection.to_s.classify.constantize
-          define_collection_attributes_setter(collection, class_name)
+          options = _collections[collection]
+          _no_collection_error(collection) unless options
+          define_collection_attributes_setter(collection, options)
         end
       end
     end
+
+    def _no_collection_error(collection)
+      klass = collection.to_s.classify
+      klass = _collections.find { |_col, opt| opt[:class_name] == klass }.first
+      suggestion = klass ? ". Did you mean #{klass}?" : ''
+      msg = "#{self} doesn't have a collection of #{collection}#{suggestion}"
+      raise ArgumentError, msg, caller
+    end
   end
 end

data/lib/lazy_record/methods.rb

@@ -5,14 +5,34 @@ module LazyRecord
   module Methods
     METHODS_MODULE_NAME = :DynamicMethods
 
+    # Defines an instance method on the calling class. The first agrument
+    # is a symbol that names the method. The second argument should be a lambda
+    # that defines the method execution. The method argument could technically
+    # be any object that responds to #to_proc and returns a Proc, but lambdas
+    # with their arity restrictions are preferred.
+    #
+    # === Example
+    #   class Thing < LazyRecord::Base
+    #     lr_method :say_hi, -> { "Hi from #{self}" }
+    #   end
+    #
+    #   thing = Thing.new # => #<Thing>
+    #   thing.say_hi      # => "Hi from #<Thing:0x007fb9629c6260>"
+    #
+    # @api public
+    #
+    # @param method_name [Symbol, String]
+    # @param method [Proc]
+    #
+    # @return [Symbol]
     def lr_method(method_name, method)
-      include mod = get_or_set_mod(METHODS_MODULE_NAME)
+      mod = get_or_set_mod(METHODS_MODULE_NAME)
 
       mod.module_eval do
-        define_method(method_name) do |*args|
-          method.call(self, *args)
-        end
+        define_method(method_name.to_sym, &method)
       end
+
+      include mod unless include?(mod)
     end
   end
 end

data/lib/lazy_record/relation.rb

@@ -6,29 +6,37 @@ module LazyRecord
   class Relation
     include Enumerable
 
-    attr_reader :model, :all
+    attr_reader :klass, :all
 
-    def initialize(model:, array: nil)
-      model = model.call if model.is_a? Proc
-      raise ArgumentError, 'model must be a class' unless model.is_a?(Class)
-      @model = model
+    def initialize(klass:, collection: [])
+      klass = klass.call if klass.is_a? Proc
+      klass_argument_error unless klass.is_a?(Class)
+      @klass = klass
       @all   = []
       self_extend_scopes_module
-      array&.each do |object|
-        @all << object && next if object.is_a?(model)
-        message = "Argument must be a collection of #{model.to_s.tableize}"
-        raise ArgumentError, message
+      collection.each do |object|
+        @all << object && next if object.is_a?(klass)
+        collection_argument_error
       end
     end
 
+    def collection_argument_error
+      message = "Argument must be a collection of #{klass.to_s.tableize}"
+      raise ArgumentError, message
+    end
+
+    def klass_argument_error
+      raise ArgumentError, '`klass` keyword argument must be a class'
+    end
+
     def <<(other)
-      message = "object must be of type #{model}"
-      raise ArgumentError, message unless other.is_a?(model)
+      message = "object must be of type #{klass}"
+      raise ArgumentError, message unless other.is_a?(klass)
       all << other unless all.include?(other)
     end
 
     def inspect
-      "\#<#{model}Relation [#{all.map(&:inspect).join(', ')}]>"
+      "\#<#{klass}Relation [#{all.map(&:inspect).join(', ')}]>"
     end
 
     def where(condition = nil)
@@ -39,7 +47,7 @@ module LazyRecord
           yield instance
         end
       end
-      self.class.new(model: model, array: result)
+      self.class.new(klass: klass, collection: result)
     end
 
     def select_by_hash_condition(condition, instance)
@@ -72,9 +80,9 @@ module LazyRecord
     private :clear, :all, :select_by_hash_condition
 
     def self_extend_scopes_module
-      return unless model.const_defined?(Scopes::SCOPE_MODULE_NAME,
+      return unless klass.const_defined?(Scopes::SCOPE_MODULE_NAME,
                                          _search_ancestors = false)
-      extend(model.const_get(Scopes::SCOPE_MODULE_NAME))
+      extend(klass.const_get(Scopes::SCOPE_MODULE_NAME))
     end
   end
 end

data/lib/lazy_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyRecord
-  VERSION = '0.6.3'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lazy_record
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - M. Simon Borg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-01 00:00:00.000000000 Z
+date: 2017-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: scoped_attr_accessor
   requirement: !ruby/object:Gem::Requirement
@@ -77,10 +77,10 @@ files:
 - lib/lazy_record/base.rb
 - lib/lazy_record/base_module.rb
 - lib/lazy_record/callbacks.rb
+- lib/lazy_record/class_methods.rb
 - lib/lazy_record/collections.rb
 - lib/lazy_record/dynamic_modules.rb
 - lib/lazy_record/methods.rb
-- lib/lazy_record/nesting.rb
 - lib/lazy_record/relation.rb
 - lib/lazy_record/scopes.rb
 - lib/lazy_record/validations.rb
@@ -98,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/lazy_record/nesting.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module LazyRecord
-  # Apply the same namespace nesting as self to another object.
-  module Nesting
-    def apply_nesting(class_name)
-      "#{to_s.split('::')[0..-3].join('::')}::#{class_name}"
-    end
-  end
-end