lazy_record 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a600da5b0f7578c40fca42e349acfdd8ead86f6
-  data.tar.gz: 39fdf3dd67b33c91235b7d18a067a55ecac89370
+  metadata.gz: 6f5ad82781d6334b11179ab0981b622e4d47494a
+  data.tar.gz: d82b3d440be2c90ff4354d557dc3f1ac8fa53ab5
 SHA512:
-  metadata.gz: cb2bbded1a40899dcdeedb83369810d4a7724fcd1b8debe0ace25549d5afb1a5927f5fcbe8c85877bfa17373afcf96db3cb144f036ec35032db677155a13d0d8
-  data.tar.gz: 02b008aa58f14d93b5d5e0f4e28c064826f795b6e47403918bff4f62a7bf827440de54a4035e9e4ec2a0fda3bc9aa6674576c1e2a7d2a8ac9a01336defd431ca
+  metadata.gz: 419b37034fd69cc6c115ede5ee8b663f589bd432ea7f25f6942378d7ced2b319e53eabf4ab056a9b063792804a6d5929934a3e23b448246302df275e6b68726b
+  data.tar.gz: 5750864f0f361b69d54e3c063b2c8b48444d903c933c957224592fb8261d363bc12f1ec175ec3fab87850d6312db525ba82bbe000907785db3ff8f8dec317785

data/README.md

@@ -1,8 +1,6 @@
 # LazyRecord
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lazy_record`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+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.
 
 ## Installation
 
@@ -22,20 +20,149 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+All objects that inherit from `LazyRecord::Base` get block syntax added to their `#initialize` method.
+
+```ruby
+class Thing < LazyRecord::Base
+end
+
+thing = Thing.new do |t|
+  t.inspect
+end
+# => #<Thing id: 1>
+```
+Every LazyRecord object is assigned an auto-incrementing ID after initialization. IDs reset when the program is terminated.
+
+Use `lr_attr_accessor` like you would use `attr_accessor`. You'll get hash syntax in your `#intialize` method for attribute setting.
+
+```ruby
+class Thing < LazyRecord::Base
+  lr_attr_accessor :stuff, :junk
+end
+
+thing = Thing.new stuff: 'stuff' do |t|
+  t.junk = 'junk'
+end
+# => #<Thing id: 1, stuff: "stuff", junk: "junk">
+```
+
+Validate presence of attributes with `lr_validates` like you would with ActiveRecord. Failed validations will return false and the ID will not be incremented. More validation options coming in the future.
+
+```ruby
+class Thing < LazyRecord::Base
+  lr_attr_accessor :stuff, :junk
+  lr_validates :stuff, presence: true
+end
+
+thing = Thing.new junk: 'junk'
+ArgumentError
+stuff must be given
+#<Thing id: nil, stuff: nil, junk: "junk">
+# => false
+```
+Use `lr_has_many` to set up associated collections of another class. `lr_belongs_to` will be added in a future update.
+
+```ruby
+class Whatever < LazyRecord::Base
+end
+
+class Thing < LazyRecord::Base
+  lr_attr_accessor :stuff, :junk
+  lr_validates :stuff, presence: true
+  lr_has_many :whatevers
+end
+
+whatever = Whatever.new
+# => #<Whatever id: 1>
+
+thing = Thing.new do |t|
+  t.stuff = 'stuff'
+  t.whatevers << whatever
+end
+# => #<Thing id: 1, stuff: "stuff", junk: nil>
+
+thing.whatevers
+# => #<WhateverRelation [#<Whatever id: 1>]>
+```
+
+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.
+
+```ruby
+class Whatever < LazyRecord::Base
+  lr_attr_accessor :party_value, :sleepy_value
+  lr_scope :big_party, -> { where('party_value > 10') }
+  lr_scope :low_sleepy, -> { where('sleepy_value < 10') }
+end
+
+class Thing < LazyRecord::Base
+  lr_attr_accessor :stuff, :junk
+  lr_validates :stuff, presence: true
+  lr_has_many :whatevers
+end
+
+Whatever.new party_value: 12, sleepy_value: 12
+Whatever.new party_value: 13, sleepy_value: 3
+Whatever.new party_value: 4, sleepy_value: 11
+Whatever.new party_value: 3, sleepy_value: 5
+thing = Thing.new do |t|
+  t.stuff = 'stuff'
+  t.whatevers = Whatever.all
+end
+# => #<Thing id: 1, stuff: "stuff", junk: nil>
+
+thing.whatevers.big_party
+# => #<WhateverRelation [#<Whatever id: 1, party_value: 12, sleepy_value: 12>, #<Whatever id: 2, party_value: 13, sleepy_value: 3>]>
+
+thing.whatevers.low_sleepy
+# => #<WhateverRelation [#<Whatever id: 2, party_value: 13, sleepy_value: 3>, #<Whatever id: 4, party_value: 3, sleepy_value: 5>]>
+
+thing.whatevers.big_party.low_sleepy
+# => #<WhateverRelation [#<Whatever id: 2, party_value: 13, sleepy_value: 3>]>
+
+Whatever.low_sleepy
+# => #<WhateverRelation [#<Whatever id: 2, party_value: 13, sleepy_value: 3>, #<Whatever id: 4, party_value: 3, sleepy_value: 5>]>
+```
+
+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.
+
+```ruby
+class Whatever < LazyRecord::Base
+  lr_attr_accessor :party_value, :sleepy_value, :right
+  lr_scope :big_party, -> { where('party_value > 10') }
+  lr_scope :low_sleepy, -> { where('sleepy_value < 10') }
+end
+
+class Thing < LazyRecord::Base
+  lr_attr_accessor :stuff, :junk
+  lr_validates :stuff, presence: true
+  lr_has_many :whatevers
+  lr_method :speak, -> (string) { puts string }
+  lr_method :add_whatever, 'hmm', 'whatevers << Whatever.new(right: hmm)'
+end
+
+thing = Thing.new stuff: 'stuff'
+thing.speak "I'm a thing"
+# I'm a thing
+# => nil
+
+thing.add_whatever(true)
+# => [#<Whatever id: 1, party_value: nil, sleepy_value: nil, right: true>]
+
+thing.whatevers
+# => #<WhateverRelation [#<Whatever id: 1, party_value: nil, sleepy_value: nil, right: true>]>
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment. There is an `example` directory with some LazyRecord classes defined.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lazy_record.
+Bug reports and pull requests are welcome on GitHub at https://github.com/msimonborg/lazy_record.
 
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/bin/console

@@ -2,14 +2,15 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'lazy_record'
+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"
-# Pry.start
+require "pry"
+Pry.start
 
-require 'irb'
-IRB.start(__FILE__)
+# require 'irb'
+# IRB.start(__FILE__)

data/config/environment.rb

@@ -0,0 +1,10 @@
+example = File.expand_path('../../example', __FILE__)
+$LOAD_PATH.unshift(example) unless $LOAD_PATH.include?(example)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'lazy_record'
+autoload :Cat,    'cat'
+autoload :Dog,    'dog'
+autoload :Friend, 'friend'
+autoload :Person, 'person'

data/example/cat.rb

@@ -0,0 +1,3 @@
+class Cat < LazyRecord::Base
+  lr_attr_accessor :name, :breed, :weight, :favorite_food
+end

data/example/dog.rb

@@ -0,0 +1,10 @@
+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
+    self.name = name + 'y' if opts[:cute] == true
+  end
+end

data/example/friend.rb

@@ -0,0 +1,3 @@
+class Friend < LazyRecord::Base
+  lr_attr_accessor :years_known
+end

data/example/person.rb

@@ -0,0 +1,78 @@
+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 = {}) {
+    opts[:dog] = {} unless opts[:dog]
+    self.new(opts) { |p| p.adopt_a_dog(opts[:dog]) }
+  }
+  lr_scope :young, -> { where('age < 30') }
+  lr_scope :short_hair, -> { where('haircut == "short"') }
+
+  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.make_people(*args, &block)
+    opts = args.extract_options!
+
+    people = args.map do |arg|
+      Person.new { |p| p.name = arg }
+    end
+
+    if opts[:count] == true
+      puts "There are #{people.size} people!"
+    end
+
+    if opts[:dog]
+      people.each do |person|
+        person.adopt_a_dog(opts[:dog]) do |d|
+          d.name = "#{person.name}'s best friend"
+        end
+      end
+    end
+
+    people.each { |person| block.call(person) } if block
+
+    people
+  end
+
+  def times(num, &block)
+    if block
+      i = 0
+      while i < num
+        block.call
+        i += 1
+      end
+      i
+    else
+      self
+    end
+  end
+
+  def adopt_a_dog(opts = {}, &block)
+    dog = Dog.new(opts)
+    block.call(dog) if block
+    self.dogs << dog
+    dog
+  end
+
+  JOE = new_with_dog(
+    name: 'Joe',
+    age: 35,
+    haircut: 'short',
+    dog: {
+      cute: true,
+      name: 'Frank',
+      breed: 'Schnauzer',
+      weight: 45,
+      friend: true,
+      years_known: 6
+    }
+  ).freeze
+end

data/lazy_record.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['msimonborg@gmail.com']
 
   spec.summary       = 'Some ActiveRecord magic for your table-less POROs. WIP.'
-  spec.description   = 'Add some convenience macros for your POROs that cut down on boilerplate code. Method definition macros, more powerful attr_accessors, and easy associations between in-memory objects. Somewhat mocks the ActiveRecord API to make it feel comfortable and intuitive for Rails developers.'
+  spec.description   = 'Add some convenience macros for your POROs that cut down on boilerplate code. Method definition macros, more powerful attr_accessors, and easy associations between in-memory objects. Somewhat mocks the ActiveRecord API to make it feel comfortable and intuitive for Rails developers. The main intent of this project is to explore dynamic programming in Ruby. Maybe someone will find it useful. WIP.'
   spec.homepage      = 'https://www.github.com/msimonborg/lazy_record'
   spec.license       = 'MIT'
   spec.add_dependency             'activesupport'

data/lib/lazy_record.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'active_support'
+require 'active_support/inflector'
 require 'lazy_record/version'
 require 'lazy_record/associations'
 require 'lazy_record/attributes'
@@ -11,4 +13,4 @@ require 'lazy_record/relation'
 require 'lazy_record/base'
 
 # Namespace
-class LazyRecord; end
+module LazyRecord; end

data/lib/lazy_record/associations.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Set up in-memory associations between POROs.
   module Associations
     COLLECTION_MODULE_NAME   = :Collections

data/lib/lazy_record/attributes.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Add special attr_accessors that automatically add initialization options
   # to your initialize method. Using lr_attr_accessor, you automatically get
   # an #initialize method that takes setter options for each attribute and

data/lib/lazy_record/base.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Inherit from LazyRecord::Base to achieve lazier development.
   #
   # LazyRecord gives you some ActiveRecord-style conveniences for your in-memory
@@ -37,7 +37,7 @@ class LazyRecord
       @all.where(condition)
     end
 
-    def initialize
+    def initialize(_opts = {})
       yield self if block_given?
     end
 
@@ -56,7 +56,8 @@ class LazyRecord
     private :id=
 
     def inspect
-      "#<#{self.class} id: #{id ? id : 'nil'}, #{instance_attrs_to_s.join(', ')}>"
+      "#<#{self.class} id: #{id ? id : 'nil'}"\
+      "#{instance_attrs_to_s.unshift('').join(', ')}>"
     end
   end
 end

data/lib/lazy_record/callbacks.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # After #initialize callbacks for validations and setting object id.
   module Callbacks
     def inherited(klass)

data/lib/lazy_record/dynamic_modules.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+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.

data/lib/lazy_record/methods.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Macro for dynamic instance method generation. Best to use for one-liners.
   module Methods
     METHODS_MODULE_NAME = :DynamicMethods

data/lib/lazy_record/relation.rb

@@ -1,32 +1,47 @@
 # frozen_string_literal: true
-class LazyRecord
-  class Relation < Array
-    attr_reader :model
+module LazyRecord
+  class Relation
+    include Enumerable
+
+    attr_reader :model, :all
 
     def initialize(model:, array: nil)
       raise ArgumentError, "model must be a class" unless model.is_a?(Class)
       @model = model
+      @all   = []
       self_extend_scopes_module
-      array.each { |object| self << object } if array
+      array.each { |object| @all << object } if array
     end
 
     def <<(other)
       unless other.is_a?(model)
         raise ArgumentError, "object must be of type #{model}"
       else
-        super
+        all << other
       end
     end
 
     def inspect
-      "\#<#{model}Relation [#{self.map(&:inspect).join(', ')}]>"
+      "\#<#{model}Relation [#{all.map(&:inspect).join(', ')}]>"
     end
 
     def where(condition)
-      result = select { |x| eval "x.#{condition}" }
+      result = all.select { |x| eval "x.#{condition}" }
       self.class.new(model: model, array: result)
     end
 
+    def each(&block)
+      all.each(&block)
+    end
+
+    def [](index)
+      all[index]
+    end
+
+    def last
+      self[-1]
+    end
+
     def self_extend_scopes_module
       if model.const_defined?(:ScopeMethods, _search_ancestors = false)
         mod = eval("#{model}::ScopeMethods")

data/lib/lazy_record/scopes.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Add ActiveRecord-style scope macros to your classes. Allows chaining.
   module Scopes
     SCOPE_MODULE_NAME = :ScopeMethods

data/lib/lazy_record/validations.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-class LazyRecord
+module LazyRecord
   # Validations callbacks. If validations don't pass then initialization
   # will return false.
   module Validations

data/lib/lazy_record/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-class LazyRecord
-  VERSION = '0.1.1'
+module LazyRecord
+  VERSION = '0.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_record
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - M. Simon Borg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-06 00:00:00.000000000 Z
+date: 2017-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -83,7 +83,8 @@ dependencies:
 description: Add some convenience macros for your POROs that cut down on boilerplate
   code. Method definition macros, more powerful attr_accessors, and easy associations
   between in-memory objects. Somewhat mocks the ActiveRecord API to make it feel comfortable
-  and intuitive for Rails developers.
+  and intuitive for Rails developers. The main intent of this project is to explore
+  dynamic programming in Ruby. Maybe someone will find it useful. WIP.
 email:
 - msimonborg@gmail.com
 executables: []
@@ -101,6 +102,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- config/environment.rb
+- example/cat.rb
+- example/dog.rb
+- example/friend.rb
+- example/person.rb
 - lazy_record.gemspec
 - lib/lazy_record.rb
 - lib/lazy_record/associations.rb