lazy_record 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5566cc3196326d3e3d61756aaedf098da67294e
-  data.tar.gz: d1c5d0beaee2366d2e443c40dca55fd2e9ced60c
+  metadata.gz: f711b308e8306e2e5425614a25e6d8fe12377f38
+  data.tar.gz: 55ec6ec6d27afffae565d3a81723a514d07289cf
 SHA512:
-  metadata.gz: 1ae86e253f89643ff48bcff171dc6d0f93778a757faa5e1b3b8f709a5c0669f3f8f5b32e6a70bf48f44a92c3d37c71587d8817f2387cfa0f4213786963d9acf4
-  data.tar.gz: '03871e46d61c8c4d21ec367a35a910752f936895fdda31972339c3b5ecc7501ec3bd5acb5b3a0c16b06fc29c2c42d240f24958bbec5c9f44709d0d974f444830'
+  metadata.gz: 3a45dc9392a008a3e51425616b0742627f25f9a9d8980bd0bcc44f56da7a2181709b7bbfb302c2ce7f0c7702896aa50cc889f74e4b359c129e1586d5d8251b9f
+  data.tar.gz: 77945dd63bae3e6344fd66eb72552c12579a9aced18c75fbb3e5ea994c1b8356f48c3d7a77adf94f11c6d270d7aa49bd41355cc15806ee21ee0dae2bd0b55e66

data/.ruby-version

@@ -1 +1 @@
-ruby-2.4.0
+ruby-2.4.1

data/README.md

@@ -1,4 +1,5 @@
 # LazyRecord
+[![Code Climate](https://codeclimate.com/github/msimonborg/lazy_record/badges/gpa.svg)](https://codeclimate.com/github/msimonborg/lazy_record)
 
 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.
 
@@ -26,9 +27,20 @@ All objects that inherit from `LazyRecord::Base` get block syntax added to their
 class Thing < LazyRecord::Base
 end
 
-thing = Thing.new do |t|
-  t.inspect
+thing = Thing.new { |t| puts t.class.superclass }
+# LazyRecord::Base
+# => #<Thing id: 1>
+```
+
+Alternatively, if you want to inherit from another class, you can mix in the `LazyRecord::BaseModule` and get all the same results.
+
+```ruby
+class Thing
+  include LazyRecord::BaseModule
 end
+
+thing = Thing.new { |t| puts t.class.superclass }
+# Object
 # => #<Thing id: 1>
 ```
 Every LazyRecord object is assigned an auto-incrementing ID after initialization. IDs reset when the program is terminated.
@@ -126,7 +138,7 @@ Whatever.where('id == 1')
 # => #<WhateverRelation [#<Whatever id: 1, 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. Only good for quick one-liners. If the method references `self` of the instance, either explicitly or implicitly, it needs to use the string syntax, since any variables not 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. 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.
 
 ```ruby
 class Whatever < LazyRecord::Base

data/Rakefile

@@ -1,3 +1,7 @@
 # frozen_string_literal: true
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
 task default: :spec

data/bin/console

@@ -4,12 +4,11 @@
 require 'bundler/setup'
 require_relative '../config/environment'
 
-
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-require "pry"
+require 'pry'
 Pry.start
 
 # require 'irb'

data/example/cat.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+# Example class
 class Cat < LazyRecord::Base
   lr_attr_accessor :name, :breed, :weight, :favorite_food
 end

data/example/dog.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+# Example class
 class Dog < LazyRecord::Base
   lr_attr_accessor :name, :breed, :weight
   lr_has_many :friends
 
   def initialize(opts = {}, &block)
     super
-    self.friends << Friend.new(opts) if opts[:friend] == true
+    friends << Friend.new(opts) if opts[:friend] == true
     self.name = name + 'y' if opts[:cute] == true
   end
 end

data/example/friend.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+# Example class
 class Friend < LazyRecord::Base
   lr_attr_accessor :years_known
 end

data/example/person.rb

@@ -1,23 +1,29 @@
+# frozen_string_literal: true
+# Example class
 class Person < LazyRecord::Base
   lr_attr_accessor :name, :age, :haircut
   lr_has_many :dogs, :cats
   lr_accepts_nested_attributes_for :dogs, :cats
 
-  can_multiply
-
-  lr_scope :new_with_dog, ->(opts = {}) {
+  lr_scope :new_with_dog, lambda { |opts = {}|
     opts[:dog] = {} unless opts[:dog]
-    self.new(opts) { |p| p.adopt_a_dog(opts[:dog]) }
+    new(opts) { |p| p.adopt_a_dog(opts[:dog]) }
   }
   lr_scope :young, -> { where('age < 30') }
-  lr_scope :short_hair, -> { where('haircut == "short"') }
+  lr_scope :old, -> { where('age > 30') }
+  lr_scope :short_hair, -> { where(haircut: 'short') }
 
-  lr_method :speak, -> (string) { puts string }
+  lr_method :speak, ->(string) { puts string }
   lr_method :add_dog, :name, 'dogs << Dog.new(name: name)'
   lr_method :introduce_yourself, 'puts "Hello, my name is #{name}"'
 
   lr_validates :name, :age, presence: true
 
+  def self.new(opts = {}, &block)
+    puts 'hi'
+    super opts, &block
+  end
+
   def self.make_people(*args, &block)
     opts = args.extract_options!
 

data/lib/lazy_record.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/inflector'
 require 'lazy_record/version'
@@ -10,6 +11,7 @@ require 'lazy_record/methods'
 require 'lazy_record/scopes'
 require 'lazy_record/validations'
 require 'lazy_record/relation'
+require 'lazy_record/base_module'
 require 'lazy_record/base'
 
 # Namespace

data/lib/lazy_record/associations.rb

@@ -1,46 +1,56 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Set up in-memory associations between POROs.
   module Associations
     COLLECTION_MODULE_NAME   = :Collections
     NESTED_ATTRS_MODULE_NAME = :NestedAttributes
 
-    def lr_has_many(*collections)
-      mod = get_or_set_and_include_mod(COLLECTION_MODULE_NAME)
+    def define_collection_getter(collection, class_name)
+      define_method(collection) do
+        if instance_variable_get("@#{collection}").nil?
+          instance_variable_set("@#{collection}", Relation.new(model: class_name))
+        end
+        instance_variable_get("@#{collection}")
+      end
+    end
 
+    def define_collection_setter(collection, class_name)
+      define_method("#{collection}=") do |coll|
+        coll = Relation.new(model: class_name, array: coll) if coll.is_a?(Array)
+        return instance_variable_set("@#{collection}", coll) if coll.is_a? Relation
+        raise ArgumentError, "Argument must be a collection of #{collection}"
+      end
+    end
+
+    def lr_has_many(*collections)
+      include mod = get_or_set_mod(COLLECTION_MODULE_NAME)
+      mod.extend(Associations)
       mod.module_eval do
         collections.each do |collection|
-          class_constant = collection.to_s.classify.constantize
-          define_method(collection) do
-            eval "@#{collection} ||= Relation.new(model: class_constant)"
-          end
+          class_name = collection.to_s.classify.constantize
+          define_collection_getter(collection, class_name)
+          define_collection_setter(collection, class_name)
+        end
+      end
+    end
 
-          define_method("#{collection}=") do |coll|
-            if coll.is_a? Array
-              coll = Relation.new(model: class_constant, array: coll)
-            end
-            if coll.is_a? Relation
-              instance_variable_set('@' + collection.to_s, coll)
-            else
-              raise ArgumentError, "Argument must be a collection of #{collection}"
-            end
-          end
+    def define_association_attributes_setter(collection, class_name)
+      define_method("#{collection}_attributes=") do |collection_attributes|
+        collection_attributes.values.each do |attributes|
+          send(collection) << class_name.new(attributes)
         end
+        collection
       end
     end
 
     def lr_accepts_nested_attributes_for(*collections)
-      mod = get_or_set_and_include_mod(NESTED_ATTRS_MODULE_NAME)
-
+      include mod = get_or_set_mod(NESTED_ATTRS_MODULE_NAME)
+      mod.extend(Associations)
       mod.module_eval do
         collections.each do |collection|
-          class_constant = collection.to_s.classify.constantize
-          define_method("#{collection}_attributes=") do |collection_attributes|
-            collection_attributes.values.each do |attributes|
-              eval "@#{collection} << #{class_name}.new(attributes)"
-            end
-            collection
-          end
+          class_name = collection.to_s.classify.constantize
+          define_association_attributes_setter(collection, class_name)
         end
       end
     end

data/lib/lazy_record/attributes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Add special attr_accessors that automatically add initialization options
   # to your initialize method. Using lr_attr_accessor, you automatically get
@@ -8,48 +9,66 @@ module LazyRecord
   module Attributes
     ATTR_MODULE_NAME = :DynamicAttributes
 
-    def lr_attr_accessor(*names)
-      mod = get_or_set_and_include_mod(ATTR_MODULE_NAME)
+    def define_setters_and_getters(name)
+      define_method(name) do
+        instance_variable_get('@' + name.to_s)
+      end
 
-      mod.module_eval do
-        names.each do |name|
-          define_method(name) do
-            instance_variable_get('@' + name.to_s)
-          end
-
-          define_method("#{name}=") do |val|
-            instance_variable_set('@' + name.to_s, val)
-          end
-        end
+      define_method("#{name}=") do |val|
+        instance_variable_set('@' + name.to_s, val)
+      end
+    end
 
-        define_method(:instance_attr_accessors) do
-          names.map(&:to_sym)
+    def define_initialize
+      define_method(:initialize) do |opts = {}, &block|
+        instance_attr_accessors.each do |attr|
+          send("#{attr}=", opts[attr.to_sym])
         end
 
-        def initialize(opts = {})
-          instance_attr_accessors.each do |attr|
-            send("#{attr}=", opts[attr.to_sym])
-          end
+        block&.call self
+        self
+      end
+    end
 
-          yield self if block_given?
-          self
+    def define_instance_attrs_to_s
+      define_method(:instance_attrs_to_s) do
+        instance_attr_accessors.map do |attr|
+          value = send(attr)
+          attr_to_s = stringify_value(value)
+          "#{attr.to_s.delete(':')}: #{attr_to_s}"
         end
+      end
+      private :instance_attrs_to_s
+    end
 
-        def instance_attrs_to_s
-          instance_attr_accessors.map do |attr|
-            value = send(attr)
-            attr_to_s = if value.is_a?(String)
-                          "\"#{value}\""
-                        elsif value.nil?
-                          'nil'
-                        else
-                          value
-                        end
-            "#{attr.to_s.delete(':')}: #{attr_to_s}"
-          end
+    def define_stringify_value
+      define_method(:stringify_value) do |value|
+        if value.is_a?(String)
+          "\"#{value}\""
+        elsif value.nil?
+          'nil'
+        else
+          value
         end
+      end
+    end
 
-        private :instance_attr_accessors, :instance_attrs_to_s
+    def define_instance_attr_accessors(*names)
+      define_method(:instance_attr_accessors) do
+        names.map(&:to_sym)
+      end
+      private :instance_attr_accessors
+    end
+
+    def lr_attr_accessor(*names)
+      include mod = get_or_set_mod(ATTR_MODULE_NAME)
+      mod.extend(Attributes)
+      mod.module_eval do
+        names.each { |name| define_setters_and_getters(name) }
+        define_instance_attr_accessors(*names)
+        define_initialize
+        define_instance_attrs_to_s
+        define_stringify_value
       end
     end
   end

data/lib/lazy_record/base.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Inherit from LazyRecord::Base to achieve lazier development.
   #
@@ -7,57 +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
-    extend Scopes
-    extend Attributes
-    extend Associations
-    extend Callbacks
-    extend Validations
-    extend Methods
-    extend DynamicModules
-
-    class << self
-      attr_reader :all
-    end
-
-    attr_writer :id
-
-    def self.count
-      @all.count
-    end
-
-    def self.first
-      @all.first
-    end
-
-    def self.last
-      @all.last
-    end
-
-    def self.where(condition)
-      @all.where(condition)
-    end
-
-    def initialize(_opts = {})
-      yield self if block_given?
-    end
-
-    def instance_attrs_to_s
-      []
-    end
-
-    def instance_attr_accessors
-      []
-    end
-
-    def id
-      @id.freeze
-    end
-
-    private :id=
-
-    def inspect
-      "#<#{self.class} id: #{id ? id : 'nil'}"\
-      "#{instance_attrs_to_s.unshift('').join(', ')}>"
-    end
+    include BaseModule
   end
 end

data/lib/lazy_record/base_module.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+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
+    def self.included(base)
+      base.extend(
+        ClassMethods,
+        Scopes,
+        Attributes,
+        Associations,
+        Callbacks,
+        Validations,
+        Methods,
+        DynamicModules
+      )
+    end
+
+    attr_writer :id
+
+    def initialize(_opts = {})
+      yield self if block_given?
+    end
+
+    def instance_attrs_to_s
+      []
+    end
+
+    def instance_attr_accessors
+      []
+    end
+
+    def inspect
+      "#<#{self.class} id: #{id ? id : 'nil'}"\
+      "#{instance_attrs_to_s.unshift('').join(', ')}>"
+    end
+
+    def id
+      @id.freeze
+    end
+
+    private :id=
+
+    # Class methods provided to all LazyRecord classes
+    module ClassMethods
+      attr_reader :all
+
+      def count
+        @all.count
+      end
+
+      def first
+        @all.first
+      end
+
+      def last
+        @all.last
+      end
+
+      def where(condition)
+        @all.where(condition)
+      end
+
+      def destroy_all
+        @all.send(:clear)
+      end
+    end
+  end
+end

data/lib/lazy_record/callbacks.rb

@@ -1,30 +1,27 @@
 # frozen_string_literal: true
+
+require 'lazy_record/dynamic_modules'
+
 module LazyRecord
   # After #initialize callbacks for validations and setting object id.
   module Callbacks
-    def inherited(klass)
-      class << klass
-        alias_method :__new, :new
-
-        def new(opts = {}, &block)
-          @all ||= Relation.new(model: self)
-          instance = __new(opts, &block)
-          if instance.respond_to?(:validation)
-            instance = instance.validation(*@validations)
-          end
-          add_id(instance)
-        end
-
-        def add_id(instance)
-          if instance
-            all << instance
-            instance.send(:id=, count)
-          end
-          instance
-        end
+    def new(opts = {}, &block)
+      @all ||= Relation.new(model: self)
+      instance = super(opts, &block)
+      if instance.respond_to?(:validation)
+        instance = instance.validation(*@validations)
+      end
+      add_id(instance)
+    end
 
-        private :add_id
+    def add_id(instance)
+      if instance
+        all << instance
+        instance.send(:id=, count)
       end
+      instance
     end
+
+    private :add_id
   end
 end

data/lib/lazy_record/dynamic_modules.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Generate dynamic modules for dynamic methods created with #define_method,
   # for insertion into inheritance chain. This allows you to make calls to
   # super for these methods.
   module DynamicModules
-    def get_or_set_and_include_mod(module_name)
+    def get_or_set_mod(module_name)
       if const_defined?(module_name, _search_ancestors = false)
         const_get(module_name)
       else
-        mod = const_set(module_name, Module.new)
-        include mod
-        mod # return the Module for variable assignment.
+        const_set(module_name, Module.new)
       end
     end
   end

data/lib/lazy_record/methods.rb

@@ -1,27 +1,17 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Macro for dynamic instance method generation. Best to use for one-liners.
   module Methods
     METHODS_MODULE_NAME = :DynamicMethods
 
-    def can_multiply
-      mod = get_or_set_and_include_mod(METHODS_MODULE_NAME)
-
-      mod.module_eval do
-        define_method(:multiply) do |num1, num2|
-          num1 * num2
-        end
-      end
-    end
-
     def lr_method(method_name, *method_args, method)
-      mod         = get_or_set_and_include_mod(METHODS_MODULE_NAME)
-      method_args = method_args.map(&:to_s).join(', ')
-      
+      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)
+        make_method_from_string(mod, method_name, *method_args, method)
       end
     end
 
@@ -31,7 +21,8 @@ module LazyRecord
       end
     end
 
-    def make_method_from_string(mod, method_name, method_args, method)
+    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} }")

data/lib/lazy_record/relation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module LazyRecord
   class Relation
     include Enumerable
@@ -6,19 +7,21 @@ module LazyRecord
     attr_reader :model, :all
 
     def initialize(model:, array: nil)
-      raise ArgumentError, "model must be a class" unless model.is_a?(Class)
+      raise ArgumentError, 'model must be a class' unless model.is_a?(Class)
       @model = model
       @all   = []
       self_extend_scopes_module
-      array.each { |object| @all << object } if array
+      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
+      end
     end
 
     def <<(other)
-      unless other.is_a?(model)
-        raise ArgumentError, "object must be of type #{model}"
-      else
-        all << other
-      end
+      message = "object must be of type #{model}"
+      raise ArgumentError, message unless other.is_a?(model)
+      all << other
     end
 
     def inspect
@@ -26,7 +29,13 @@ module LazyRecord
     end
 
     def where(condition)
-      result = all.select { |x| eval "x.#{condition}" }
+      result = all.select do |x|
+        if condition.is_a? Hash
+          condition.all? { |key, val| x.send(key) == val }
+        else
+          eval "x.#{condition}"
+        end
+      end
       self.class.new(model: model, array: result)
     end
 
@@ -42,11 +51,15 @@ module LazyRecord
       self[-1]
     end
 
+    def clear
+      all.clear
+    end
+
+    private :clear, :all
+
     def self_extend_scopes_module
-      if model.const_defined?(:ScopeMethods, _search_ancestors = false)
-        mod = eval("#{model}::ScopeMethods")
-        extend(mod)
-      end
+      return unless model.const_defined?(:ScopeMethods, _search_ancestors = false)
+      extend(model::ScopeMethods)
     end
   end
 end

data/lib/lazy_record/scopes.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Add ActiveRecord-style scope macros to your classes. Allows chaining.
   module Scopes
     SCOPE_MODULE_NAME = :ScopeMethods
 
     def lr_scope(method_name, lambda)
-      if const_defined?(SCOPE_MODULE_NAME, _search_ancestors = false)
-        mod = const_get(SCOPE_MODULE_NAME)
-      else
-        mod = const_set(SCOPE_MODULE_NAME, Module.new)
-        extend mod
-      end
-
+      extend mod = get_or_set_mod(SCOPE_MODULE_NAME)
       mod.module_eval do
         send(:define_method, method_name, &lambda)
       end

data/lib/lazy_record/validations.rb

@@ -1,30 +1,31 @@
 # frozen_string_literal: true
+
 module LazyRecord
   # Validations callbacks. If validations don't pass then initialization
   # will return false.
   module Validations
     VALIDATIONS_MODULE_NAME = :ModelValidations
 
-    def lr_validates(*args)
-      mod = get_or_set_and_include_mod(VALIDATIONS_MODULE_NAME)
+    def define_validation
+      define_method(:validation) do |*params|
+        params.each do |param|
+          if send(param.to_sym).nil?
+            puts "#{param} must be given", inspect
+            return false
+          end
+        end
+        self
+      end
+    end
 
+    def lr_validates(*args)
+      include mod = get_or_set_mod(VALIDATIONS_MODULE_NAME)
+      mod.extend(Validations)
       opts = args.extract_options!
       @validations = args
-      if opts[:presence] == true
-
-        mod.module_eval do
-          define_method(:validation) do |*params|
-            params.each do |param|
-              begin
-                raise ArgumentError if send(param.to_sym).nil?
-              rescue => e
-                puts e, "#{param} must be given", inspect
-                return false
-              end
-            end
-            self
-          end
-        end
+      return unless opts[:presence] == true
+      mod.module_eval do
+        define_validation
       end
     end
   end

data/lib/lazy_record/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module LazyRecord
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_record
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - M. Simon Borg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-07 00:00:00.000000000 Z
+date: 2017-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -112,6 +112,7 @@ files:
 - lib/lazy_record/associations.rb
 - lib/lazy_record/attributes.rb
 - lib/lazy_record/base.rb
+- lib/lazy_record/base_module.rb
 - lib/lazy_record/callbacks.rb
 - lib/lazy_record/dynamic_modules.rb
 - lib/lazy_record/methods.rb
@@ -1466,7 +1467,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Some ActiveRecord magic for your table-less POROs. WIP.