lazy_record 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e001b11d0607098306b11994a55436e0f1ee6a9
-  data.tar.gz: a38d5dc0d58a33665aaea2b3bedd7c7b22018f8a
+  metadata.gz: e834e5aa45c25ab443c4d34a59898f94be6c242f
+  data.tar.gz: ee98fd7313a9a99a61a2f359242c38a4d8f6fd2a
 SHA512:
-  metadata.gz: aeadbadcb0ffe05bd58a86996734aebfe9f9e0cccdc89e428874857e1d2b51e83c3e9de4813956e69ae8886ca9bdb95427b87f5a9a3683f8dde8366f43e8cf23
-  data.tar.gz: 262e1db0468746deb5c76300f5297159cca1aeea6e98b54d0e6a680e155ef6a49b768835a770e71fe2296d1059c4c62909210fa086af59e21e4ddae299a92577
+  metadata.gz: cf4f07d687c4998664c1f2a31e74b5dca56bd9b489e60478fc01c14d8d8f956510e42c15eedc72f4e1f6837a97d55ca42d5bb54fa1621e7533e93e5b8fc60c42
+  data.tar.gz: eb64a330301f566edace26f5375af57ae1a2c9fdc509d772d55d6b7edb95fd613a9aaafb5d39e3f5f972be12c23b68c42127879dff0300bfb00b89496395e36d

data/.rubocop.yml

@@ -3,3 +3,6 @@ Metrics/LineLength:
   Exclude:
     - 'lazy_record.gemspec'
     - 'spec/spec_helper.rb'
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: false

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in lazy_record.gemspec

data/README.md

@@ -123,13 +123,13 @@ thing.whatevers
 # => #<WhateverRelation [#<Whatever>]>
 ```
 
-Use `lr_scope` and `#where` to create class scope methods and query objects. Works just like ActiveRecord scopes, including scope chaining. Only since it is all Ruby and no SQL, use `==` as the comparison operator.
+Use `lr_scope` and `#where` to create class scope methods and query objects.
 
 ```ruby
 class Whatever < LazyRecord::Base
   attr_accessor :party_value, :sleepy_value
-  lr_scope :big_party, -> { where('party_value > 10') }
-  lr_scope :low_sleepy, -> { where('sleepy_value < 10') }
+  lr_scope :big_party, -> { where { |w| w.party_value > 10 } }
+  lr_scope :low_sleepy, -> { where { |w| w.sleepy_value < 10 } }
 end
 
 class Thing < LazyRecord::Base
@@ -160,7 +160,7 @@ thing.whatevers.big_party.low_sleepy
 Whatever.low_sleepy
 # => #<WhateverRelation [#<Whatever party_value: 13, sleepy_value: 3>, #<Whatever id: 4, party_value: 3, sleepy_value: 5>]>
 
-Whatever.where('party_value == 12')
+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.
@@ -180,33 +180,29 @@ 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. Can use lambda syntax or string syntax. Best for quick one-liners. If the method references `self` of the instance, either explicitly or implicitly, it needs to use the string syntax, since anything passed into the lambda will be evaluated in the context of the Class level scope.
+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.
 
 ```ruby
 class Whatever < LazyRecord::Base
   attr_accessor :party_value, :sleepy_value, :right
-  lr_scope :big_party, -> { where('party_value > 10') }
-  lr_scope :low_sleepy, -> { where('sleepy_value < 10') }
+  lr_scope :big_party, -> { where { |w| w.party_value > 10 } }
+  lr_scope :low_sleepy, -> { where { |w| w.sleepy_value < 10 } }
 end
 
 class Thing < LazyRecord::Base
   attr_accessor :stuff, :junk
   lr_validates :stuff, presence: true
   lr_has_many :whatevers
-  lr_method :speak, -> (string) { puts string }
-  lr_method :add_whatever, 'right', 'whatevers << Whatever.new(right: right)'
+  lr_method :speak, -> (_x, string) { puts string }
+  lr_method :what_am_i, ->(x) { "I'm a #{x.class}" }
 end
 
 thing = Thing.new stuff: 'stuff'
 thing.speak "I'm a thing"
 # I'm a thing
 # => nil
-
-thing.add_whatever(true)
-# => [#<Whatever party_value: nil, sleepy_value: nil, right: true>]
-
-thing.whatevers
-# => #<WhateverRelation [#<Whatever party_value: nil, sleepy_value: nil, right: true>]>
+thing.what_am_i
+# => "I'm a Thing"
 ```
 
 ## Development

data/Rakefile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/config/environment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 example = File.expand_path('../../example', __FILE__)
 $LOAD_PATH.unshift(example) unless $LOAD_PATH.include?(example)
 lib = File.expand_path('../lib', __FILE__)

data/lazy_record.gemspec

@@ -1,5 +1,6 @@
 # coding: utf-8
 # frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lazy_record/version'

data/lib/lazy_record.rb

@@ -1,5 +1,25 @@
 # frozen_string_literal: true
 
+# Copyright (c) 2017 M. Simon Borg
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
 require 'active_support'
 require 'active_support/inflector'
 require 'scoped_attr_accessor'
@@ -18,5 +38,19 @@ require 'lazy_record/relation'
 require 'lazy_record/base_module'
 require 'lazy_record/base'
 
-# Namespace
+# A collection of convenience methods for adding enhanced constructors,
+# attributes, one-to-many collections, one-to-one associations, scopes,
+# methods, and basic validations. Get a lot done with a little code.
+#
+# Inherit from LazyRecord::Base or include LazyRecord::BaseModule to
+# unlock the features. The primary use case in mind is a toolkit
+# for designing response objects for web API wrappers. Two
+# other gems in progress that are using LazyRecord for this purpose are
+# <tt>pyr</tt>(https://www.github.com/msimonborg/pyr) (Ruby interface
+# for Phone Your Rep, a civic tool), and
+# <tt>lapi</tt>(https://www.github.com/msimonborg/lapi), an API wrapper
+# building tool with the goal of easing the construction of simple
+# Ruby API wrappers.
+#
+# This library's API draws heavy inspiration from ActiveRecord.
 module LazyRecord; end

data/lib/lazy_record/base_module.rb

@@ -27,6 +27,47 @@ module LazyRecord
       yield self if block_given?
     end
 
+    def inspect
+      format('#<%s%s>',
+             self.class,
+             displayable_attributes.join(', '))
+    end
+
+    def associations
+      []
+    end
+
+    def collections
+      []
+    end
+
+    def ==(other)
+      conditions = set_equality_conditions
+      return false if !other.is_a?(self.class) || conditions.empty?
+      conditions.all? { |attr| send(attr) == other.send(attr) }
+    end
+
+    def ===(other)
+      conditions = set_equality_conditions
+      return false if !other.is_a?(self.class) || conditions.empty?
+      # rubocop:disable Style/CaseEquality
+      conditions.all? { |attr| send(attr) === other.send(attr) }
+      # rubocop:enable Style/CaseEquality
+    end
+
+    def hash
+      conditions = set_equality_conditions
+      hash = {}
+      conditions.each { |attr| hash[attr] = send(attr) }
+      hash.hash
+    end
+
+    alias eql? ==
+
+    def set_equality_conditions
+      self.class.send(:attr_readers) + associations
+    end
+
     def collection_counts_to_s
       []
     end
@@ -43,12 +84,6 @@ module LazyRecord
       []
     end
 
-    def inspect
-      format('#<%s%s>',
-             self.class,
-             displayable_attributes.join(', '))
-    end
-
     def displayable_attributes
       attributes = [
         public_attr_readers_to_s.dup,
@@ -69,9 +104,12 @@ module LazyRecord
       end
     end
 
-    private :stringify_value,
+    private :displayable_attributes,
+            :stringify_value,
             :public_attr_readers_to_s,
-            :collection_counts_to_s
+            :collection_counts_to_s,
+            :associations_to_s,
+            :set_equality_conditions
 
     # Class methods provided to all LazyRecord classes
     module ClassMethods

data/lib/lazy_record/methods.rb

@@ -5,28 +5,12 @@ module LazyRecord
   module Methods
     METHODS_MODULE_NAME = :DynamicMethods
 
-    def lr_method(method_name, *method_args, method)
+    def lr_method(method_name, method)
       include mod = get_or_set_mod(METHODS_MODULE_NAME)
 
-      if method.respond_to?(:call)
-        make_method_from_proc(mod, method_name, method)
-      else
-        make_method_from_string(mod, method_name, *method_args, method)
-      end
-    end
-
-    def make_method_from_proc(mod, method_name, proc)
-      mod.module_eval do
-        send(:define_method, method_name, &proc)
-      end
-    end
-
-    def make_method_from_string(mod, method_name, *method_args, method)
-      method_args = method_args.map(&:to_s).join(', ')
       mod.module_eval do
-        define_method(method_name) do |*params|
-          block = eval("lambda { |#{method_args}| #{method} }")
-          block.call(*params)
+        define_method(method_name) do |*args|
+          method.call(self, *args)
         end
       end
     end

data/lib/lazy_record/relation.rb

@@ -37,8 +37,6 @@ module LazyRecord
           select_by_hash_condition(condition, instance)
         elsif block_given?
           yield instance
-        elsif condition
-          eval "instance.#{condition}"
         end
       end
       self.class.new(model: model, array: result)
@@ -71,7 +69,7 @@ module LazyRecord
       all.clear
     end
 
-    private :clear, :all
+    private :clear, :all, :select_by_hash_condition
 
     def self_extend_scopes_module
       return unless model.const_defined?(Scopes::SCOPE_MODULE_NAME,

data/lib/lazy_record/scopes.rb

@@ -7,8 +7,9 @@ module LazyRecord
 
     def lr_scope(method_name, lambda)
       extend mod = get_or_set_mod(SCOPE_MODULE_NAME)
+
       mod.module_eval do
-        send(:define_method, method_name, &lambda)
+        define_method(method_name, &lambda)
       end
     end
   end

data/lib/lazy_record/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lazy_record
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - M. Simon Borg