embedded 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b50128771dd929a10a666a66162b6d474cae251
+  data.tar.gz: ab834feb4633a90efd4e74e6cc8ad6605bc7685c
+SHA512:
+  metadata.gz: ec6877b0001ab2025c75dd53f7aefb8dd6244d91b9a429bf262801e04317a0d8785f2d9bd3b384adc78c50bb288c65b48928de616c3a2424e9d0d206f0abc54a
+  data.tar.gz: 7250302a6d36404c2d77f070f9ecf092d5283a538556e4140475a504f5772ce841837e59a2b15e70a5861ae03129f633c60c91e05fbc9048e5392e37aee13505

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 jvillarejo
+
+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.

data/README.md

@@ -0,0 +1,225 @@
+# Embedded
+
+Embedded is a small rails engine to correctly persist Value Objects in Active Record Object columns
+
+## Motivation
+
+There objects in every domain that doesn't have an identity by itself but their equality depends on the values of their attributes.
+
+Example: prices, any magnitude, a color, a polygon.
+
+Defining a value objects lets you extract common behavior from your current bloated active record objects.
+
+Every time that I did this I had to define a getter and setter for the value object and map those to the columns of the object that gets persisted, so I thought it would be better to define those value object attributes in a declarative way and let the plugin do the magic behind.
+
+For more info about value objects check this links:
+
+* [Value Object by Martin Fowler](https://martinfowler.com/bliki/ValueObject.html)
+* [Don't forget about Value Objects](https://plainoldobjects.com/2017/03/19/dont-forget-about-value-objects)
+
+## Features
+
+It lets you define value objects and map them into the corresponding value object attributes columns
+
+It lets you query by those value objects in a safe way, without monkeypatching the default activerecord classes
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'embedded'
+```
+
+Create an initializer in your rails project
+
+```ruby
+# config/initializers/embedded_initializer
+ActiveRecord::Base.send(:extend, Embedded::Model)
+```
+
+Or you can extend the ApplicationRecord class
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  extend Embedded::Model
+  self.abstract_class = true
+end
+```
+
+
+## Usage
+
+Let's say you have a Reservation in your active record model and that reservation has a start_time, and end_time. And want you calculate the duration in hours of the period.
+
+```ruby
+  class Reservation < ApplicationRecord
+
+    def period_in_hours
+      (end_time - start_time).round / 60 / 60
+    end
+  end
+```
+
+```ruby
+  reservation = Reservation.new(start_time: Time.now, end_time: 3.hours.ago)
+  reservation.period_in_hours
+  # => 3
+```
+
+ If you want your model to have cohesion, something is not quite right when a reservation is calculating time intervals of a period, but let's keep that for a while.
+
+ You have a new requirement, you need to persist available hours for a shop, and you want to calculate the duration in hours of the available time
+
+ ```ruby
+   class Shop < ApplicationRecord
+      def opening_period_in_hours
+        (open_time - closed_time).round / 60 / 60
+      end
+   end
+ ```
+
+ ```ruby
+  shop = Shop.new(start_time: Time.now, end_time: 3.hours.ago)
+  shop.period_in_hours
+  # => 3
+```
+
+Now you are starting to see the problem. That behavior belongs to a TimeInterval object that has start_time and end_time and let's you calculate all durations and intervals you want.
+
+So with embedded in hand we can do this.
+
+We have a reservation that has an attribute scheduled_time of type TimeInterval and will map the start_time and end_time attributes to the ones in TimeInterval
+
+```ruby
+class Reservation < ApplicationRecord
+  embeds :scheduled_time, attrs: [:start_time, :end_time], class_name: 'TimeInterval'
+end
+```
+
+The same here with the shop
+
+```ruby
+class Shop < ApplicationRecord
+  embeds :available_time, attrs: [:start_time, :end_time], class_name: 'TimeInterval'
+end
+```
+
+TimeInterval is a plain PORO, it just need the attributes that you defined in your activerecord objects mapping.
+
+```ruby
+  class TimeInterval
+    attr_reader :start_time, :end_time
+
+    def initialize(values)
+      @start_time = values.fetch(:start_time)
+      @end_time = values.fetch(:end_time)
+
+      # you can validate as you want, here or in a valid? method that you define
+    end
+
+    def hours
+      minutes / 60
+    end
+
+    def minutes
+      seconds / 60
+    end
+
+    def seconds
+      (end_time - start_time).round
+    end
+  end
+```
+
+Now you can pass available time to shop constructor and check the duration directly
+ ```ruby
+  t = TimeInterval.new(start_time: Time.now, end_time: 3.hours.ago)
+  shop = Shop.new(available_time: t)
+  shop.available_time.hours
+  # => 3
+```
+Also you can persist the reservation and when fetching it back of the db it will scheduled_time will be a TimeInterval
+
+```ruby
+  t = TimeInterval.new(start_time: Time.now, end_time: 3.hours.ago)
+  reservation = Reservation.create(scheduled_time: t)
+
+  reservation.reload
+
+  reservation.scheduled_time.hours
+  # => 3
+```
+
+### Database Mapping
+
+Your table columns have to be named in a specific way so they are mapped correctly, for example:
+
+Reservation attribute name is scheduled_time and as TimeInterval has start_time and end_time your column names must be defined as scheduled_time_start_time and scheduled_time_end_time
+
+```ruby
+class CreateReservations < ActiveRecord::Migration
+  def change
+    create_table :reservations do |t|
+      t.timestamp :scheduled_time_start_time
+      t.timestamp :scheduled_time_end_time
+
+      t.timestamps
+    end
+  end
+end
+```
+
+Shop attribute name is available time and as TimeInterval has start_time and end_time attributes, your column names here must be defined as available_time_start_time and available_time_end_time
+
+```ruby
+class CreateShops < ActiveRecord::Migration
+  def change
+    create_table :shops do |t|
+      t.timestamp :available_time_start_time
+      t.timestamp :available_time_end_time
+
+      t.timestamps
+    end
+  end
+end
+```
+
+### Querying
+
+For example you have now a model that has prices in different currencies. 
+
+```ruby
+price = Price.new(currency: 'BTC', amount: BigDecimal.new('2.5'))
+my_gamble = BuyOrder.create(price: price, created_at: Time.new(2015,03,17))
+
+bubble_price = Price.new(currency: 'USD', amount: BigDecimal.new('5257'))
+my_intelligent_investment = SellOrder.create(price: price, created_at: Time.new(2017,10,18))
+```
+
+And we want to check the orders for a specific price we can do this.
+
+```ruby
+price = Price.new(currency: 'BTC', amount: BigDecimal.new('2.5'))
+gambles = BuyOrder.embedded.where(price: price).to_a
+
+# => [#<Order id: 1, price_currency: "BTC", price_amount: #<BigDecimal:555e61776630,'0.25E1',18(36)>, created_at: "2017-03-17 17:11:00", updated_at: "2017-10-18 17:11:00">]
+```
+
+In order to search with values you should specify with embedded method. This decision was made because I didn't want to monkey patch the activerecord method 'where'.
+
+With this way the embedded method returns another scope in which the method 'where' is overridden. If you want to query by the column attributes you can still use the default 'where' method. 
+
+```ruby
+jpm_orders = BuyOrder.where(price_currency: 'BTC')
+jpm_orders.find_each {|o| o.trader.fire! }
+``` 
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/jvillarejo/embedded/issues)
+- Fix bugs and [submit pull requests](https://github.com/jvillarejo/embedded/pulls)
+- Suggest or add new features
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Embedded'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/embedded.rb

@@ -0,0 +1,5 @@
+require 'embedded/scope'
+require 'embedded/model'
+
+module Embedded
+end

data/lib/embedded/model.rb

@@ -0,0 +1,36 @@
+module Embedded
+  module Model
+    def embedded_column_names(embeddable_attr, attributes)
+      attributes.inject({}) do |hash, a|
+        hash.merge(:"#{embeddable_attr}_#{a}" => a)
+      end
+    end
+
+    def embedded
+      Embedded::Scope.new(self.all,embedded_attributes)
+    end
+
+    def embeds(embeddable_attr, options = {})
+      cattr_accessor :embedded_attributes
+      self.embedded_attributes ||= {}
+      self.embedded_attributes[embeddable_attr] = options
+
+      attributes = options[:attrs]
+      columns = embedded_column_names(embeddable_attr,attributes)
+      clazz = options[:class_name] ? options[:class_name].constantize : embeddable_attr.to_s.camelcase.constantize
+
+      self.send(:define_method, embeddable_attr) do
+        values = columns.inject({}) do |hash,(k,v)|
+          hash.merge(v=>read_attribute(k))
+        end
+        clazz.new(values)
+      end
+
+      self.send(:define_method, :"#{embeddable_attr}=") do |v|
+        columns.each do |k,a|
+          self.write_attribute(k, v.send(a))
+        end
+      end
+    end
+  end
+end

data/lib/embedded/scope.rb

@@ -0,0 +1,32 @@
+module Embedded
+  class Scope
+    def initialize(scope,attributes)
+      @attributes = attributes
+      @scope = scope
+    end
+
+    def embedded_attributes_for(embeddable_attr, value = nil)
+      @attributes[embeddable_attr][:attrs].inject({}) do |a,attr|
+        a.merge(:"#{embeddable_attr}_#{attr}" => value ? value.send(attr) : nil)
+      end
+    end
+
+    def where(opts = :chain, *rest)
+      if opts.is_a?(Hash)
+        opts = opts.inject({}) do |h,(k,v)|
+          if @attributes[k]
+            h.merge(embedded_attributes_for(k,v))
+          else
+            h
+          end
+        end
+      end
+
+      self.class.new(@scope.where(opts, *rest), @attributes)
+    end
+
+    def method_missing(method, *args, &block)
+      @scope.send(method,*args,&block)
+    end
+  end
+end

data/lib/embedded/version.rb

@@ -0,0 +1,3 @@
+module Embedded
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: embedded
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jvillarejo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Rails plugin that makes value objects embedded into activerecord objects
+email:
+- arzivian87@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/embedded.rb
+- lib/embedded/model.rb
+- lib/embedded/scope.rb
+- lib/embedded/version.rb
+homepage: https://github.com/jvillarejo/embedded
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Use value objects with activerecord objects
+test_files: []