quantum_fields 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 75256efead78bb5b4cf0fb0addf73eb4ebc4e541c5a549b2f26a0708a2dbc7b6
+  data.tar.gz: 783c270ceb4e8d3fae1a2bb3669fe075694c5137a8816bab8d48dd10340e0621
+SHA512:
+  metadata.gz: 319478c26780c49f9862863882239d5a11056bc8ec1c30895a1be826e4c01af04f562d3e5d72e9b9bc854cf19c13cfff815a4bf1e109635ed1e13baa0a303995
+  data.tar.gz: 936e0ef4b000b0370f9a060c769583e62029a820f129d47c9b9e2e49ebdaa4b8901be50db9e427ccc5ebac64ba589a1a3f6b8de5b9931e07bb2d1feb125a7597

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Fernando Bellincanta
+
+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,74 @@
+# QuantumFields [![Build Status](https://travis-ci.com/ErvalhouS/quantum_fields.svg?branch=master)](https://travis-ci.com/ErvalhouS/quantum_fields) [![Maintainability](https://api.codeclimate.com/v1/badges/48fd7d9c967edc9327fe/maintainability)](https://codeclimate.com/github/ErvalhouS/quantum_fields/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/48fd7d9c967edc9327fe/test_coverage)](https://codeclimate.com/github/ErvalhouS/quantum_fields/test_coverage) [![Inline docs](http://inch-ci.org/github/ErvalhouS/quantum_fields.svg?branch=master)](http://inch-ci.org/github/ErvalhouS/quantum_fields)
+
+### Give noSQL powers to your SQL database
+QuantumFields is a gem to extend your Rails model's making them able to use virtual fields from a JSON column or a Text column serialized as a Hash. This means that you can use fields that were not explicitly declared in your schema as if they were.
+
+This feature is dependent in one of two things:
+
+  1. Your model's table should include a Hstore, JSON or JSONB column
+  2. Your model's table should include a Text column that gets serialized as a Hash
+
+You should prioritize option 1 since it translates all queries into SQL, which is great for performance. If your database does not support Hstore, JSON or JSONB you are stuck with option 2, which depends on PORO manipulation of your datasets.
+
+## Usage
+To add noSQL behavior into your model you just need to call `no_sqlize` on it.
+```ruby
+class MyModel < ActiveRecord::Base
+  no_sqlize
+end
+```
+
+This initializes the behavior on default a column called `quantum_fields`. If you wish to use another column you need declare it explicitily
+```ruby
+class MyModel < ActiveRecord::Base
+  no_sqlize fields_column: :my_json_field
+end
+```
+
+All ActiveRecord queries will now translate SQLs to QuantumFields using JSON operators, allowing you to do:
+```ruby
+>> MyModel.create(a_column_that_does_not_exists: 'I do exist')
+# => #<Person id: 1, quantum_fields: { a_column_that_does_not_exists: 'I do exist' }>
+>> MyModel.where(a_column_that_does_not_exists: 'I do exist')
+# => [ #<Person id: 1, quantum_fields: { a_column_that_does_not_exists: 'I do exist' }> ]
+>> MyModel.all.order(:a_column_that_does_not_exists)
+# => [ #<Person id: 1, quantum_fields: { a_column_that_does_not_exists: 'I do exist' }> ]
+>> MyModel.last.a_column_that_does_not_exists
+# => 'I do exist'
+>> MyModel.last.a_column_that_does_not_exists = "I'm here!"
+# => 'I'm here!'
+# And so on...
+```
+
+You can also perform per-record validations, which can get injected by a `quantum_rules` attribute. This means that if you set a record with a presence validator for a God QuantumField saving without it would raise an exception.
+```ruby
+>> object = MyModel.new
+>> object.quantum_rules = { god: { validates: { presence: true } } }
+>> object.save!
+# => ActiveRecord::RecordInvalid: Validation failed: God can't be blank
+```
+
+This column is optional, but you can use any column you'd like for it by explicitily declaring in your `no_sqlize` call.
+```ruby
+class MyModel < ActiveRecord::Base
+  no_sqlize rules_column: :my_json_field
+end
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quantum_fields'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/ErvalhouS/quantum_fields. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant code of conduct](http://contributor-covenant.org/). To find good places to start contributing, try looking into our issue list and our Codeclimate profile.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+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    = 'QuantumFields'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/quantum_fields.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'quantum_fields/active_record_patch'
+require 'quantum_fields/no_sqlize'
+require 'quantum_fields/railtie'
+require 'quantum_fields/validation_injector'
+
+# A module to abstract a noSQL aproach into SQL records, using a `parameters`
+# JSON column.
+module QuantumFields
+  extend ActiveSupport::Concern
+  # This module contains the methods called within the Model to initialize
+  # and to manage how the other methods should behave on the given context.
+  module ClassMethods
+    def no_sqlize(args = {})
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def self.fields_column
+          :#{args[:fields_column] || :quantum_fields}
+        end
+        def self.rules_column
+          :#{args[:rules_column] || :quantum_rules}
+        end
+        def as_json(*args)
+          super.except(self.class.fields_column.to_s, self.class.rules_column.to_s).tap do |hash|
+            self.try(:quantum_fields)&.each do |key, value|
+              hash[key] = value
+            end
+          end
+        end
+      RUBY
+      include QuantumFields::NoSqlize
+      include QuantumFields::ValidationInjector
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, QuantumFields)

data/lib/quantum_fields/active_record_patch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+ActiveRecord::PredicateBuilder.class_eval do
+  def build(attribute, value)
+    if table.type(attribute.name).force_equality?(value)
+      bind = build_bind_attribute(attribute.name, value)
+      attribute.eq(bind)
+    elsif table.send('klass').respond_to?(:fields_column) && !table.send('klass').column_names.include?(attribute.name)
+      json_key = attribute.name
+      attribute.name = table.send('klass').fields_column.to_s
+      op = Arel::Nodes::InfixOperation.new('->>', table.send('klass').arel_table[table.send('klass').fields_column], Arel::Nodes.build_quoted(json_key))
+      bind = build_bind_attribute(op, value)
+      op.eq(bind)
+    else
+      handler_for(value).call(attribute, value)
+    end
+  end
+end
+ActiveRecord::Relation.class_eval do
+  def arel_attribute(name) # :nodoc:
+    if klass.column_names.include?(name.to_s) || !klass.respond_to?(:fields_column)
+      klass.arel_attribute(name, table)
+    else
+      Arel::Nodes::InfixOperation.new('->>',
+                                      klass.arel_table[klass.fields_column],
+                                      Arel::Nodes.build_quoted(name))
+    end
+  end
+end
+
+ActiveModel::AttributeMethods::ClassMethods.module_eval do
+  # Is +new_name+ an alias or a quantum field?
+  def attribute_alias?(new_name)
+    attribute_aliases.key?(new_name.to_s) ||
+      (!['all', 'star', ' ', '*'].include?(new_name.to_s) &&
+        respond_to?(:fields_column) &&
+        !column_names.include?(new_name.to_s))
+  end
+  # Returns the original name or quantum field for the alias +name+
+  def attribute_alias(name)
+    if column_names.include?(name.to_s) || !respond_to?(:fields_column)
+      attribute_aliases[name.to_s]
+    else
+      name
+    end
+  end
+end

data/lib/quantum_fields/no_sqlize.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module QuantumFields
+  # Module to enable virtual methods in moduls, it creates necessary
+  # methods to simulate the behavior that any field can exist, getting
+  # or setting it is like a migrated column behaves.
+  module NoSqlize
+    extend ActiveSupport::Concern
+    # Overriding `method_missing` does the magic of assigning an absent field
+    # into `.parameters` JSON as a key-value pair, or recovering it's value if
+    # exists.
+    def method_missing(meth, *args, &block)
+      if can_no_sqlize?
+        no_sqlize!(meth, *args, &block)
+      else
+        raise NotImplementedError,
+              "#{model.table_name} should have a `#{fields_column}` JSON column"
+      end
+    rescue StandardError
+      super
+    end
+
+    # Used to map which methods can be called in the instance, it is based on
+    # the premisse that you can always assign a value to any field and recover
+    # only existing fields or the ones that are in the `.parameters` JSON.
+    def respond_to_missing?(method_name, include_private = false)
+      meth = method_name.to_s
+      can_no_sqlize? && meth.ends_with?('=') || meth.ends_with?('changed?') ||
+        try(fields_column).try(:[], meth).present? ||
+        super
+    end
+
+    # Overriding a ActiveRecord method that is used in `.create` and `.update`
+    # methods to assign a value into an attribute.
+    def _assign_attribute(key, value)
+      initialize_fields
+      public_send("#{key}=", value) ||
+        try(fields_column).try(:except!, key.to_s)
+    end
+
+    private
+
+    # Retrieves current model class
+    def model
+      self.class
+    end
+
+    # Retrieves  fields_column configured in current scope
+    def fields_column
+      model.fields_column
+    end
+
+    # Checks for `.parameters` presence and initializes it.
+    def initialize_fields
+      try("#{fields_column}=", {}) unless try(fields_column).present?
+    end
+
+    # The behavior that a noSQL method should have. It either assigns a value into
+    # an attribute or retrieves it's value, depending in the method called.
+    def no_sqlize!(meth, *args, &_block)
+      method_name = meth.to_s
+      initialize_fields
+      if method_name.ends_with?('=')
+        assing_to(method_name.chomp('='), args.first)
+      else
+        try(fields_column).try(:[], method_name)
+      end
+    end
+
+    # Assings a value to a key in :fields_column which allows saving any virtual
+    # attribute
+    def assing_to(param, value)
+      try(fields_column).try(:[]=, param, value)
+    end
+
+    # Checks if requirements are met for the feature
+    def can_no_sqlize?
+      model.column_names.include?(fields_column.to_s) &&
+        %i[json jsonb].include?(no_sqlize_column.type)
+    end
+
+    # Retrieve which column is being used to sqlize
+    def no_sqlize_column
+      model.columns.find { |col| col.name == fields_column.to_s }
+    end
+  end
+end

data/lib/quantum_fields/railtie.rb

@@ -0,0 +1,4 @@
+module QuantumFields
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/quantum_fields/validation_injector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module QuantumFields
+  # This module injects a behavior on no_sqlized models that enables backend
+  # validations on virtual fields based on rules passed by the instance
+  module ValidationInjector
+    extend ActiveSupport::Concern
+    included do
+      before_validation :map_injected_validations
+      def map_injected_validations
+        send(self.class.rules_column).try(:deep_symbolize_keys)&.each do |field, rules|
+          validations = rules[:validates]
+          inject_validations(field, validations) if validations.present?
+        end
+      end
+
+      def inject_validations(field, validations)
+        validations.each do |method, value|
+          singleton_class.validates field, method => value
+        end
+      end
+    end
+  end
+end

data/lib/quantum_fields/version.rb

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

data/lib/tasks/quantum_fields_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :quantum_fields do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: quantum_fields
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fernando Bellincanta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: QuantumFields is a gem to extend your Rails model's making them able
+  to use virtual fields from a JSON column or a Text column serialized as a Hash.
+  This means that you can use fields that were not explicitly declared in your schema
+  as if they were.
+email:
+- ervalhous@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/quantum_fields.rb
+- lib/quantum_fields/active_record_patch.rb
+- lib/quantum_fields/no_sqlize.rb
+- lib/quantum_fields/railtie.rb
+- lib/quantum_fields/validation_injector.rb
+- lib/quantum_fields/version.rb
+- lib/tasks/quantum_fields_tasks.rake
+homepage: https://github.com/ErvalhouS/quantum_fields
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Give noSQL powers to your SQL database
+test_files: []