dynabute 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edc3d0e7b6d1de057c81eee5df5be4b2d9d2b449
+  data.tar.gz: 348d882a6cbc060a772d072a19f5f472f40cd792
+SHA512:
+  metadata.gz: 8254f230e971e306d577cfa962daba8bf60a1138d88fd4508834fe301012ba6beb62aa004c01a1c700d6e95aa234a715a4bdf9003e294a67f541fddddeb2b945
+  data.tar.gz: a19ec2cbf89b9be2004bc04f6a59e62519548f2cb6fbcc9c5ff8c955351cafa3ca693c0b0e89350dc79cbcda6b591afc65cbf9ca82d73a7da57a8c90b9776759

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Liooo
+
+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,78 @@
+# Dynabute
+Dynamically add attributes on Relational Database backed ActiveRecord, without hash serialization and bullshits
+
+## Usage
+
+First, enable dynabute
+```ruby
+class User < ActiveRecord::Base
+  has_dynabutes
+end
+````
+
+then add some field definitions
+```ruby
+User.dynabutes << Dynabute::Field.new( name: 'age', value_type: 'integer' )
+User.dynabutes << Dynabute::Field.new( name: 'skinny', value_type: 'boolean' )
+User.dynabutes << Dynabute::Field.new( name: 'personality', value_type: 'string', has_many: true )
+```
+
+now set value
+```ruby
+user = User.create
+
+user.build_dynabute_value( name: 'age' )
+# => <Dynabute::Values::IntegerValue:0x007faba5279540 id: nil, field_id: 1, dynabutable_id: 1, dynabutable_type: "User", value: nil>
+
+user.build_dynabute_value( name: 'age' ).update( value: 35 )
+user.dynabute_value( name: 'age' ).value
+#=> 35
+```
+
+values can also be referenced by `dynabute_<field name>_value(s)`
+```ruby
+user.dynabute_age_value
+# => <Dynabute::Values::IntegerValue:0x007faba5279540 id: 1, field_id: 1, dynabutable_id: 1, dynabutable_type: "User", value: 35>
+```
+
+nested attributes of glory
+```ruby
+personality_field_id = User.dynabutes.find_by( name: 'personality' ).id
+user.update(
+  dynabute_values_attributes: [
+    { name: 'age', value: 36 }, #=> tell us which field to update by `name:`
+    { name: 'skinny', value: false },
+    { field_id: personality_field_id, value: 'introverted' }, # or by `field_id:`
+    { field_id: personality_field_id, value: 'stingy' }
+  ]
+)
+```
+
+check all dynabute values
+```ruby
+user.dynabute_values
+#=> [#<Dynabute::Values::IntegerValue:0x007ff4230e90d8 id: 1, field_id: 1, dynabutable_id: 1, dynabutable_type: "User", value: 36>,
+     #<Dynabute::Values::BooleanValue:0x007fd03ecb84f8 id: 1, field_id: 2, dynabutable_id: 1, dynabutable_type: "User", value: false>,
+     #<Dynabute::Values::StringValue:0x007fd03b347ef8 id: 1, field_id: 3, dynabutable_id: 1, dynabutable_type: "User", value: "introverted">,
+     #<Dynabute::Values::StringValue:0x007fd03e992080 id: 1, field_id: 3, dynabutable_id: 1, dynabutable_type: "User", value: "stingy">]
+```
+ 
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dynabute'
+```
+
+And then execute:
+```bash
+$ bundle install
+$ rails generate dynabute:install
+$ rake db:migrate
+```
+
+## Contributing
+yea?
+
+## 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,20 @@
+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    = 'Dynabute'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+Bundler::GemHelper.install_tasks

data/lib/dynabute.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+require 'dynabute/field'
+require 'dynabute/dynabutable'
+require 'dynabute/values'
+require 'dynabute/option'
+
+module Dynabute
+  class FieldNotFound < StandardError
+    def initialize(*criteria); @criteria = criteria; end
+    def to_s; "No dynabute field #{@criteria.compact.first} found"; end
+  end
+
+  module ClassMethods
+    def has_dynabutes
+      include Dynabutable
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend Dynabute::ClassMethods
+end

data/lib/dynabute/dynabutable.rb

@@ -0,0 +1,76 @@
+require 'dynabute/util'
+require 'dynabute/joins'
+require 'dynabute/nested_attributes'
+
+module Dynabute
+  module Dynabutable
+    extend ActiveSupport::Concern
+
+    included do
+      include Joins::Dynabutable
+      include NestedAttributes::API
+
+      (Dynabute::Field::TYPES).each do |t|
+        has_many Util.value_relation_name(t), class_name: Util.value_class_name(t), as: :dynabutable
+        accepts_nested_attributes_for Util.value_relation_name(t)
+      end
+
+      def self.dynabutes
+        Dynabute::Field.for(self.to_s)
+      end
+
+      def self.dynabute_relation_names
+        Util.all_value_relation_names
+      end
+
+      def dynabute_fields
+        Dynabute::Field.for(self.class.to_s)
+      end
+
+      def dynabute_values
+        @dynabute_values ||= dynabute_fields
+                               .group_by{|f| f.value_type}
+                               .map { |type, fields|
+                                 fields.first.value_class.where(field_id: fields.map(&:id), dynabutable_id: id)
+                               }.flatten.compact
+      end
+
+      def dynabute_value(name: nil, id: nil, field: nil)
+        field = find_field(name, id, field)
+
+        if field.has_many
+          send(Util.value_relation_name(field.value_type)).where(field_id: field.id)
+        else
+          send(Util.value_relation_name(field.value_type)).find_by(field_id: field.id)
+        end
+      end
+
+      def build_dynabute_value(name: nil, id: nil, field: nil)
+        field = find_field(name, id, field)
+        send(Util.value_relation_name(field.value_type)).build(field_id: field.id)
+      end
+
+      def method_missing(*args)
+        name = args[0]
+        one = name.to_s.scan(/^dynabute_(.+)_value$/)[0]
+        many = name.to_s.scan(/^dynabute_(.+)_values$/)[0]
+        return super if one.nil? && many.nil?
+        target = one ? one : many
+        candidates = [target[0], target[0].gsub('_', ' ')]
+        field = Dynabute::Field.find_by(name: candidates)
+        return super if field.nil?
+        dynabute_value(field: field)
+      end
+
+      private
+      def find_field(name, id, field)
+        name_or_id = {name: name, id: id}.compact
+        return nil if name_or_id.blank? && field.blank?
+        field_obj = field || Dynabute::Field.find_by(name_or_id.merge(target_model: self.class.to_s))
+        fail Dynabute::FieldNotFound.new(name_or_id, field) if field_obj.nil?
+        field_obj
+      end
+
+    end
+  end
+end

data/lib/dynabute/field.rb

@@ -0,0 +1,37 @@
+require 'dynabute/util'
+require 'dynabute/joins'
+
+module Dynabute
+  class Field < ActiveRecord::Base
+    include Joins::Field
+    def self.table_name_prefix; 'dynabute_'; end
+
+    TYPES = %w(string integer boolean datetime select)
+    validates :value_type, inclusion: {in: TYPES}
+    scope :for, ->(klass){ where(target_model: klass) }
+    has_many :options, class_name: 'Dynabute::Option', dependent: :destroy
+    accepts_nested_attributes_for :options, allow_destroy: true
+    def is_select?
+      ['select'].include? value_type
+    end
+
+    def value_class
+      type = is_select? ? :integer : value_type
+      Util.value_class_name(type).safe_constantize
+    end
+
+    def self.<<(records)
+      if records.respond_to? :each
+        records.each {|r| r.update!(target_model: get_parent_class_name) }
+      else
+        records.update!(target_model: get_parent_class_name)
+      end
+      all
+    end
+
+    private
+    def self.get_parent_class_name
+      all.where_clause.binds.detect{|w| w.name == 'target_model'}.try(:value)
+    end
+  end
+end

data/lib/dynabute/joins.rb

@@ -0,0 +1,38 @@
+module Dynabute
+  module Joins
+    module Field
+      extend ActiveSupport::Concern
+      def joined_alias
+        "#{value_type}_#{id}"
+      end
+
+    end
+
+    module Dynabutable
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def join_to_fields(fields)
+          fields.inject(self) do |me, field|
+            me.joins(join_source_for_field(field))
+          end
+        end
+
+        private
+        def join_source_for_field(field)
+          value_table = field.value_class.arel_table.alias(field.joined_alias)
+          dynabutee_table
+            .join(value_table, Arel::Nodes::OuterJoin)
+            .on(
+              dynabutee_table[:id].eq(value_table[:dynabutable_id]).and(
+              value_table[:dynabutable_type].eq(self.to_s)).and(
+              value_table[:field_id].eq(field.id))
+            ).join_sources
+        end
+
+        def dynabutee_table
+          arel_table
+        end
+      end
+    end
+  end
+end

data/lib/dynabute/nested_attributes.rb

@@ -0,0 +1,82 @@
+require 'dynabute/util'
+
+module Dynabute
+  module NestedAttributes
+    class FieldNotSpecified < StandardError; end
+    class Builder
+      def initialize(attributes_list, dynabutee)
+        @attributes_list = attributes_list
+        @nested_attributes_to_assign = {}
+        @dynabutee = dynabutee
+      end
+
+      def build_assignable_attributes
+        desperados = [] # has_one params without :id key need special care
+        collect_fields(@attributes_list)
+        @attributes_list.each do |attrs|
+          field = resolve_field(attrs)
+          next let_go(field, attrs) if field.has_many
+          next let_go(field, attrs) if attrs[:id].present?
+          desperados.push([attrs, field])
+        end
+
+        desperados
+          .group_by { |(_, field)| field.value_type }
+          .each do |value_type, attrs_fields| # for each value tables
+
+          existing_values = @dynabutee.send(Util.value_relation_name(value_type))
+                              .where(field_id: attrs_fields.map{|(_, f)| f.id})
+                              .to_a # trying to reduce queries
+          attrs_fields.each do |(attrs, field)| # for each attrs
+            params = {
+              id: existing_values.detect{|v| v.field_id == field.id}.try(:id),
+              value: attrs[:value],
+              field_id: field.id
+            }
+            let_go(field, params)
+          end
+        end
+        yield(@nested_attributes_to_assign)
+      end
+
+      private
+      def resolve_field(attrs)
+        @field_list.detect{|f| f.name == attrs[:name] || f.id == attrs[:field_id]}
+      end
+
+      def collect_fields(attrs)
+        params = attrs.each_with_object({field_id: [], name: []}) do |a, memo|
+          if a[:field_id] then memo[:field_id].push(a[:field_id])
+          elsif a[:name] then memo[:name].push(a[:name])
+          else fail FieldNotSpecified end
+        end
+        table = Dynabute::Field.arel_table
+        @field_list = Dynabute::Field.for(@dynabutee.class.name)
+          .where( table[:id].in(params[:field_id]).or(table[:name].in(params[:name])) )
+      end
+
+      def let_go(field, params)
+        relation = Util.value_relation_name(field.value_type)
+        (@nested_attributes_to_assign[relation] ||= []).push(params)
+      end
+    end
+
+    module API
+      extend ActiveSupport::Concern
+
+      # - value: value
+      # - (field_id || name): to identify the field
+      # - id?:
+      #   -- has_many: to determine create or update
+      #   -- has_one: if the corresponding value record exists, will be added either way
+      def dynabute_values_attributes=(attributes_list)
+        Builder.new(attributes_list, self).build_assignable_attributes do |attributes|
+          attributes.each do |relation, params|
+            # this is a private method so can't call from inside Builder
+            assign_nested_attributes_for_collection_association(relation, params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynabute/option.rb

@@ -0,0 +1,6 @@
+module Dynabute
+  class Option < ActiveRecord::Base
+    belongs_to :dynabute_field, class_name: 'Dynabute::Field'
+    validates_presence_of :label
+  end
+end

data/lib/dynabute/util.rb

@@ -0,0 +1,21 @@
+module Dynabute
+  module Util
+    def value_class_name(type)
+      name = %i(select).include?(type.to_sym) ? :integer : type
+      "Dynabute::Values::#{name.to_s.classify}Value"
+    end
+    module_function :value_class_name
+
+    def value_relation_name(type)
+      %i(select).include?(type.to_sym) ?
+        :integer_values :
+        "#{type}_values".to_sym
+    end
+    module_function :value_relation_name
+
+    def all_value_relation_names
+      Dynabute::Field::TYPES.map{|t| Util.value_relation_name(t).uniq }
+    end
+    module_function :all_value_relation_names
+  end
+end

data/lib/dynabute/values.rb

@@ -0,0 +1,5 @@
+require('dynabute/values/base')
+require('dynabute/values/boolean_value')
+require('dynabute/values/datetime_value')
+require('dynabute/values/integer_value')
+require('dynabute/values/string_value')

data/lib/dynabute/values/base.rb

@@ -0,0 +1,17 @@
+module Dynabute::Values
+  module Base
+    extend ActiveSupport::Concern
+
+    included do
+      def self.table_name_prefix; 'dynabute_'; end
+      belongs_to :dynabutable, polymorphic: true
+      belongs_to :dynabute_field, class_name: 'Dynabute::Field'
+
+      def value_type
+        dynabute_field.value_type
+      end
+    end
+
+  end
+
+end

data/lib/dynabute/values/boolean_value.rb

@@ -0,0 +1,7 @@
+module Dynabute
+  module Values
+    class BooleanValue < ActiveRecord::Base
+      include Dynabute::Values::Base
+    end
+  end
+end

data/lib/dynabute/values/datetime_value.rb

@@ -0,0 +1,7 @@
+module Dynabute
+  module Values
+    class DatetimeValue < ActiveRecord::Base
+      include Dynabute::Values::Base
+    end
+  end
+end

data/lib/dynabute/values/integer_value.rb

@@ -0,0 +1,7 @@
+module Dynabute
+  module Values
+    class IntegerValue < ActiveRecord::Base
+      include Dynabute::Values::Base
+    end
+  end
+end

data/lib/dynabute/values/string_value.rb

@@ -0,0 +1,7 @@
+module Dynabute
+  module Values
+    class StringValue < ActiveRecord::Base
+      include Dynabute::Values::Base
+    end
+  end
+end

data/lib/dynabute/version.rb

@@ -0,0 +1,3 @@
+module Dynabute
+  VERSION = '0.0.3'
+end

data/lib/generators/dynabute/install_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Dynabute
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path("../templates", __FILE__)
+    desc "This generator installs migrations for Dynabute"
+    # argument :stylesheets_type, :type => :string, :default => 'less', :banner => '*less or static'
+    # class_option :'no-coffeescript', :type => :boolean, :default => false, :desc => 'Skips coffeescript replacement into app generators'
+
+    def self.next_migration_number(path)
+      next_migration_number = current_migration_number(path) + 1
+      ActiveRecord::Migration.next_migration_number(next_migration_number)
+    end
+
+    def copy_migrations
+      migration_template 'migration.rb', "db/migrate/create_dynabutes.rb"
+    end
+  end
+end

data/lib/generators/dynabute/templates/migration.rb

@@ -0,0 +1,47 @@
+class CreateDynabutes < ActiveRecord::Migration[5.1]
+  def change
+    create_table "dynabute_fields", force: :cascade do |t|
+      t.string   "name", limit: 50
+      t.string   "value_type", limit: 15
+      t.boolean  "has_many", default: false
+      t.string   "target_model", limit: 50
+    end
+    add_index "dynabute_fields", ["target_model", "name"], name: "index_dynabute_fields_on_target_model_and_name", using: :btree
+
+    create_table "dynabute_string_values", force: :cascade do |t|
+      t.integer  "field_id", limit: 4
+      t.integer  "dynabutable_id", limit: 4
+      t.string   "dynabutable_type", limit: 50
+      t.string   "value", limit: 255
+    end
+    add_index "dynabute_string_values", ["dynabutable_id"], name: "dynabute_string_values_on_recordable_id", using: :btree
+    add_index "dynabute_string_values", ["dynabutable_id", "field_id"], name: "dynabute_string_values_on_record_id_and_recordable_id", using: :btree
+
+    create_table "dynabute_integer_values", force: :cascade do |t|
+      t.integer  "field_id", limit: 4
+      t.integer  "dynabutable_id", limit: 4
+      t.string   "dynabutable_type", limit: 50
+      t.integer  "value"
+    end
+    add_index "dynabute_integer_values", ["dynabutable_id"], name: "dynabute_integer_values_on_recordable_id", using: :btree
+    add_index "dynabute_integer_values", ["dynabutable_id", "field_id"], name: "dynabute_integer_values_on_record_id_and_recordable_id", using: :btree
+
+    create_table "dynabute_boolean_values", force: :cascade do |t|
+      t.integer  "field_id", limit: 4
+      t.integer  "dynabutable_id", limit: 4
+      t.string   "dynabutable_type", limit: 50
+      t.boolean  "value"
+    end
+    add_index "dynabute_boolean_values", ["dynabutable_id"], name: "dynabute_boolean_values_on_recordable_id", using: :btree
+    add_index "dynabute_boolean_values", ["dynabutable_id", "field_id"], name: "dynabute_boolean_values_on_record_id_and_recordable_id", using: :btree
+
+    create_table "dynabute_datetime_values", force: :cascade do |t|
+      t.integer  "field_id", limit: 4
+      t.integer  "dynabutable_id", limit: 4
+      t.string   "dynabutable_type", limit: 50
+      t.boolean  "value"
+    end
+    add_index "dynabute_datetime_values", ["dynabutable_id"], name: "dynabute_datetime_values_on_recordable_id", using: :btree
+    add_index "dynabute_datetime_values", ["dynabutable_id", "field_id"], name: "dynabute_datetime_values_on_record_id_and_recordable_id", using: :btree
+  end
+end

data/lib/tasks/dynabute_tasks.rake

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

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: dynabute
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Liooo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.8
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: sqlite3
+  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: pry-byebug
+  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: pry-rails
+  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-rails
+  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: Dynamically add attributes on ActiveRecord.
+email:
+- ryoyamada3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/dynabute.rb
+- lib/dynabute/dynabutable.rb
+- lib/dynabute/field.rb
+- lib/dynabute/joins.rb
+- lib/dynabute/nested_attributes.rb
+- lib/dynabute/option.rb
+- lib/dynabute/util.rb
+- lib/dynabute/values.rb
+- lib/dynabute/values/base.rb
+- lib/dynabute/values/boolean_value.rb
+- lib/dynabute/values/datetime_value.rb
+- lib/dynabute/values/integer_value.rb
+- lib/dynabute/values/string_value.rb
+- lib/dynabute/version.rb
+- lib/generators/dynabute/install_generator.rb
+- lib/generators/dynabute/templates/migration.rb
+- lib/tasks/dynabute_tasks.rake
+homepage: https://github.com/Liooo/dynabute
+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.6.12
+signing_key: 
+specification_version: 4
+summary: DYNAmic attriBUTEs for ActiveRecord
+test_files: []