schemattr 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3162b47b2a1acf700ca81a8ee47222391cf0711ad4b5194b9d5c46cf19584162
-  data.tar.gz: 12b294d20e189e9d16bb23644a26199829bccd3c42ba1b7662aea33b79ae4662
+  metadata.gz: 1ed48f215b1651cfcaca945564ee28889209196633128c453c25050c93948092
+  data.tar.gz: 1d93e1999e211d8168b2f1dea9bb650043afe606a0c6c2eeb006689a6f4184eb
 SHA512:
-  metadata.gz: 1134ffee2611f6f203f3891fe21088121a80f7ceb6a02197dd8cf4aa97b114d575a82c6652217faafb840ecbf6dbf904d61169984ee3cf7fb499dcb035f1a2fe
-  data.tar.gz: dee2aa5f9b8120885f8a0422de822e5ced1bf60103668149963d8ce8866c535db0915123427968af0b3b85653fb18626540190bad2ca16120da5bd79c7385c26
+  metadata.gz: e38303d1c00e993a70b4f64dd37287aef23b3eac18a4a233482adc01e9ed90714a71b50128208eb8f46ec26d2e0c5e7c965470cf9e4cbd7b328a663ca0492f6e
+  data.tar.gz: 43361ee53cabc37ca4f3e538cf93d1fb4328584e4564e0230cb7a352a375d59895c7ca9503fa71e3287638490780bc7cd0b80de1fd56a40ffbfc0f2a311fd302

data/{MIT.LICENSE → MIT-LICENSE}

@@ -1,6 +1,4 @@
-Copyright 2015 Jeremy Jackson / ModeSet
-
-https://github.com/modeset/schemattr
+Copyright 2023 Jeremy Jackson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,12 +1,13 @@
-Schemattr
-=========
+# Schemattr - Schema-ish ActiveRecord attributes 
 
-[![Gem Version](https://img.shields.io/gem/v/schemattr.svg)](http://badge.fury.io/rb/schemattr)
-[![Build Status](https://img.shields.io/travis/modeset/schemattr.svg)](https://travis-ci.org/modeset/schemattr)
-[![Code Climate](https://codeclimate.com/github/modeset/schemattr/badges/gpa.svg)](https://codeclimate.com/github/modeset/schemattr)
-[![Test Coverage](https://codeclimate.com/github/modeset/schemattr/badges/coverage.svg)](https://codeclimate.com/github/modeset/schemattr)
-[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
-[![Dependency Status](https://gemnasium.com/modeset/schemattr.svg)](https://gemnasium.com/modeset/schemattr)
+<img alt="Shemattr" width="150" height="144" src="https://user-images.githubusercontent.com/13765/255353418-61285561-09cf-4208-8dd5-c00455e4288a.png" align="right" hspace="20">
+
+[![Gem Version](https://img.shields.io/gem/v/schemattr.svg?label=gem%20version)](https://rubygems.org/gems/schemattr)
+[![MIT License](https://img.shields.io/github/license/jejacks0n/schemattr.svg)](https://opensource.org/licenses/MIT)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/jejacks0n/schemattr/ci.yml.svg?label=build%20status)](https://github.com/jejacks0n/schemattr/actions/workflows/ci.yml)
+[![Maintainability](https://img.shields.io/codeclimate/coverage-letter/jejacks0n/schemattr.svg?label=maintainability)](https://codeclimate.com/github/jejacks0n/schemattr/maintainability)
+[![Test Coverage](https://img.shields.io/codeclimate/coverage/jejacks0n/schemattr.svg?label=test%20coverage)](https://codeclimate.com/github/jejacks0n/schemattr/test_coverage)
+[![RubyGems](https://img.shields.io/gem/dt/schemattr.svg?label=rubygems%20downloads)](https://rubygems.org/gems/schemattr)
 
 Schemattr is an ActiveRecord extension that provides a helpful schema-less attribute DSL. It can be used to define a
 simple schema for a single attribute that can change over time without having to migrate existing data.
@@ -34,36 +35,23 @@ methods, can keep a real column synced with one if its fields, and more.
 If you're using Schemattr and want to add a new setting field, it's as simple as adding a new field to the attribute
 schema and setting a default right there in the code. No migrations, no hassles, easy deployment.
 
+## Download and Installation
 
-## Table of Contents
-
-1. [Installation](#installation)
-2. [Usage](#usage)
-  - [Field types](#field-types)
-  - [Delegating](#delegating)
-  - [Strict mode](#strict-mode-vs-arbitrary-fields)
-  - [Overriding](#overriding-functionality)
-  - [Renaming fields](#renaming-fields)
-  - [Syncing attributes](#syncing-attributes)
-
+Add this line to your Gemfile:
 
-## Installation
-
-Add it to your Gemfile:
 ```ruby
-gem 'schemattr'
+gem "schemattr"
 ```
 
-And then execute:
-```shell
-$ bundle
-```
+Or install the latest version with RubyGems:
 
-Or install it yourself as:
-```shell
-$ gem install schemattr
+```bash
+gem install schemattr
 ```
 
+Source code can be downloaded as part of the project on GitHub:
+
+* https://github.com/jejacks0n/schemattr
 
 ## Usage
 
@@ -73,7 +61,7 @@ First, let's create a migration to add your schema-less attribute. In postgres y
 postgres JSON type as our example because the JSON type allows queries and indexing, and hstore does annoying things to
 booleans. We don't need to set our default value to an empty object because Schemattr handles that for us.
 
-*Note*: If you're using a different database provider, like sqlite3 for instance, you can use a text column and tell
+_Note_: If you're using a different database provider, like sqlite3 for instance, you can use a text column and tell
 ActiveRecord to serialize that column (e.g. `serialize :settings` in your model). Though, you won't be able to easily
 query in these cases so consider your options.
 
@@ -104,8 +92,8 @@ Notice that we've done nothing else, but we already have a working version of wh
 ```
 user = User.new
 user.settings.opted_in? # => true
-user.settings.email_group_advanced? # => false 
-user.settings.email_group_expert? # => false 
+user.settings.email_group_advanced? # => false
+user.settings.email_group_expert? # => false
 ```
 
 If we save the user at this point, these settings will be persisted. We can also make changes to them at this point, and
@@ -117,18 +105,19 @@ they'll just be the defaults if we ever ask again.
 The various field types are outlined below. When you define a string field for instance, the value will be coerced into
 a string at the time that it's set.
 
-type     | description
----------|--------------
-boolean  | boolean value
-string   | string value  
-text     | same as string type
-integer  | number value
-bigint   | same as integer
-float    | floating point number value
-decimal  | same as float
-datetime | datetime object
-time     | time object (stored the same as datetime)
-date     | date object
+| type     | description                               |
+|----------|-------------------------------------------|
+| boolean  | boolean value                             |
+| string   | string value                              |
+| text     | same as string type                       |
+| integer  | number value                              |
+| bigint   | same as integer                           |
+| float    | floating point number value               |
+| decimal  | same as float                             |
+| datetime | datetime object                           |
+| time     | time object (stored the same as datetime) |
+| date     | date object                               |
+| hash     | hash object                               |
 
 You can additionally define your own types using `field :foo, :custom_type` and there will no coercion at the time the
 field is set -- this is intended for when you need something that doesn't care what type it is. This generally makes it
@@ -140,9 +129,9 @@ If you don't like the idea of having to access these attributes at `user.setting
 delegated. This adds delegation of the methods that exist on settings to the User instances.
 
 ```ruby
-  attribute_schema :settings, delegated: true do
-    field :opted_in, :boolean, default: true
-  end
+attribute_schema :settings, delegated: true do
+  field :opted_in, :boolean, default: true
+end
 ```
 
 ```ruby
@@ -157,13 +146,13 @@ user.opted_in? # => false
 By default, Schemattr doesn't allow arbitrary fields to be added, but it supports it. When strict mode is disabled, it
 allows any arbitrary field to be set or asked for.
 
-*Note*: When delegated and strict mode is disabled, you cannot set arbitrary fields on the model directly and must
+_Note_: When delegated and strict mode is disabled, you cannot set arbitrary fields on the model directly and must
 access them through the attribute that you've defined -- in our case, it's `settings`.
 
 ```ruby
-  attribute_schema :settings, delegated: true, strict: false do
-    field :opted_in, :boolean, default: true
-  end
+attribute_schema :settings, delegated: true, strict: false do
+  field :opted_in, :boolean, default: true
+end
 ```
 
 ```ruby
@@ -186,17 +175,17 @@ class UserSettings < Schemattr::Attribute
     !self[:opted_in]
   end
   alias_method :opted_out, :opted_out?
-  
+
   def opted_out=(val)
-    opted_in = !val
+    self.opted_in = !val
   end
 end
 ```
 
 ```ruby
-  attribute_schema :settings, class: UserSettings do
-    field :opted_in, :boolean, default: true
-  end
+attribute_schema :settings, class: UserSettings do
+  field :opted_in, :boolean, default: true
+end
 ```
 
 ```ruby
@@ -230,7 +219,7 @@ class UserSettings < Schemattr::Attribute
 end
 ```
 
-*Note*: This is not a real world scenario but serves our purposes of describing an example. 
+_Note_: This is not a real world scenario but serves our purposes of describing an example.
 
 ### Renaming fields
 
@@ -240,16 +229,18 @@ shown thus far. But you've added new email lists, and you think `opted_in` is to
 We can create a new field that is correctly named, and specify what attribute we want to pull the value from.
 
 ```ruby
-  attribute_schema :settings do
-    # field :opted_in, :boolean, default: true
-    field :email_list_beginner, :boolean, from: :opted_in, default: true
-  end
+attribute_schema :settings do
+  # field :opted_in, :boolean, default: true
+  field :email_list_beginner, :boolean, value_from: :opted_in, default: true
+end
 ```
 
-Specifying the `from: :opted_in` option will tell Schemattr to look for the value that may have already been defined in
+Specifying the `value_from: :opted_in` option will tell Schemattr to look for the value that may have already been defined in
 `opted_in` before the rename. This allows for slow migrations, but you can also write a migration to ensure this happens
 quickly.
 
+This previously used the keyword `from`, and this keyword is deprecated.
+
 ### Syncing attributes
 
 There's a down side to keeping some things internal to this settings attribute. You can query JSON types in postgres,
@@ -260,9 +251,9 @@ Let's say we want to be able to be able to easily query users who have opted in.
 leave it, as the case may be) on the users table.
 
 ```ruby
-  attribute_schema :settings do
-    field :email_list_beginner, :boolean, default: true, sync: :opted_in
-  end
+attribute_schema :settings do
+  field :email_list_beginner, :boolean, default: true, sync: :opted_in
+end
 ```
 
 ```ruby
@@ -281,7 +272,6 @@ things in sync easier. The second issue can arise is when this attribute is set
 using things like `user.update_column(:opted_in, false)`, and `User.update_all(opted_in: false)` will allow things to
 get out of sync.
 
-
 ## Querying a JSON column
 
 This has come up a little bit, and so it's worth documenting -- though it has very little to do with Schemattr. When you
@@ -292,16 +282,17 @@ these are the common scenarios that we've used.
 
 ```
 User.where("(settings->>'opted_in')::boolean") # boolean query
-User.where("settings->>'string_value' = ?", "some string") # string query 
+User.where("settings->>'string_value' = ?", "some string") # string query
 ```
 
-
 ## License
 
-Licensed under the [MIT License](http://creativecommons.org/licenses/MIT)
+This project is released under the MIT license:
 
-Copyright 2015 [Mode Set](https://github.com/modeset)
+* https://opensource.org/licenses/MIT
 
+Copyright 2023 [jejacks0n](https://github.com/jejacks0n)
 
 ## Make Code Not War
-![crest](https://secure.gravatar.com/avatar/aa8ea677b07f626479fd280049b0e19f?s=75)
+
+[![forthebadge](http://forthebadge.com/images/badges/built-with-love.svg)](http://forthebadge.com)

data/lib/schemattr/active_record_extension.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Schemattr
   module ActiveRecordExtension
     module ClassMethods
@@ -23,7 +25,7 @@ module Schemattr
         end
 
         define_method "#{name}" do
-          _schemaless_attributes[name] ||= attribute_schema.attribute_class.new(self, name, options[:strict] == false)
+          schemaless_attributes[name] ||= attribute_schema.attribute_class.new(self, name, options[:strict] == false)
         end
       end
     end
@@ -33,14 +35,13 @@ module Schemattr
     end
 
     def reload(*_args)
-      _schemaless_attributes.keys.each { |name| _schemaless_attributes[name] = nil }
+      schemaless_attributes.keys.each { |name| schemaless_attributes[name] = nil }
       super
     end
 
     private
-
-    def _schemaless_attributes
-      @_schemaless_attributes ||= {}
-    end
+      def schemaless_attributes
+        @_schemaless_attributes ||= {}
+      end
   end
 end

data/lib/schemattr/attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Schemattr
   class Attribute
     attr_accessor :model, :attr_name, :hash
@@ -22,39 +24,38 @@ module Schemattr
     end
 
     private
+      def method_missing(m, *args)
+        if @allow_arbitrary_attributes
+          self[$1] = args[0] if args.length == 1 && /^(\w+)=$/ =~ m
+          self[m.to_s.gsub(/\?$/, "")]
+        else
+          raise NoMethodError, "undefined method '#{m}' for #{self.class}"
+        end
+      end
 
-    def method_missing(m, *args)
-      if @allow_arbitrary_attributes
-        self[$1] = args[0] if args.length == 1 && /^(\w+)=$/ =~ m
-        self[m.to_s.gsub(/\?$/, "")]
-      else
-        raise NoMethodError, "undefined method '#{m}' for #{self.class}"
+      def migrate_value(val, from)
+        return val unless from
+        if (old_val = self[from]).nil?
+          val
+        else
+          @hash.delete(from.to_s)
+          old_val
+        end
       end
-    end
 
-    def migrate_value(val, from)
-      return val unless from
-      if (old_val = self[from]).nil?
+      def sync_value(val, to)
+        model[to] = val if to
         val
-      else
-        @hash.delete(from.to_s)
-        old_val
       end
-    end
-
-    def sync_value(val, to)
-      model[to] = val if to
-      val
-    end
 
-    def []=(key, val)
-      hash[key.to_s] = val
-      model[attr_name] = hash
-      val
-    end
+      def []=(key, val)
+        hash[key.to_s] = val
+        model[attr_name] = hash
+        val
+      end
 
-    def [](key)
-      hash[key.to_s]
-    end
+      def [](key)
+        hash[key.to_s]
+      end
   end
 end

data/lib/schemattr/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Schemattr
   class DSL
     attr_accessor :attribute_class, :delegated, :defaults
@@ -13,74 +15,83 @@ module Schemattr
     end
 
     protected
-
-    def field(name, type, options = {})
-      if respond_to?(type, true)
-        send(type, name, options)
-      else
-        _define(name, false, options)
+      def field(name, type, options = {})
+        if options[:from].present?
+          options[:value_from] = options.delete(:from)
+          log_warning(name, type, options[:value_from])
+        end
+
+        if respond_to?(type, true)
+          send(type, name, options)
+        else
+          define(name, false, options)
+        end
       end
-    end
 
-    def string(name, options = {})
-      _define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_s, options[:sync]) }
-    end
+      def string(name, options = {})
+        define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_s, options[:sync]) }
+      end
 
-    def integer(name, options = {})
-      _define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_i, options[:sync]) }
-    end
+      def integer(name, options = {})
+        define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_i, options[:sync]) }
+      end
 
-    def float(name, options = {})
-      _define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_f, options[:sync]) }
-    end
+      def float(name, options = {})
+        define name, false, options, setter: lambda { |val| sync_value(self[name] = val.to_f, options[:sync]) }
+      end
 
-    def datetime(name, options = {})
-      _define name, false, options
-    end
+      def datetime(name, options = {})
+        define name, false, options
+      end
 
-    def date(name, options = {})
-      _define name, false, options
-    end
+      def date(name, options = {})
+        define name, false, options
+      end
 
-    def boolean(name, options = {})
-      _define name, true, options, setter: lambda { |val|
-        bool = ActiveRecord::Type::Boolean.new.deserialize(val)
-        sync_value(self[name] = bool, options[:sync])
-      }
-    end
+      def boolean(name, options = {})
+        define name, true, options, setter: lambda { |val|
+          bool = ActiveRecord::Type::Boolean.new.deserialize(val)
+          sync_value(self[name] = bool, options[:sync])
+        }
+      end
 
-    alias_method :text, :string
-    alias_method :bigint, :integer
-    alias_method :decimal, :float
-    alias_method :time, :datetime
+      alias_method :text, :string
+      alias_method :bigint, :integer
+      alias_method :decimal, :float
+      alias_method :time, :datetime
 
     private
+      def define(name, boolean, options, blocks = {})
+        setter = blocks[:setter] || lambda { sync_value(self[name] = val, options[:sync]) }
+        getter = blocks[:getter] || lambda { migrate_value(self[name], options[:value_from]) }
+        default_for(name, options[:default])
+        method_for("#{name}=", options[:sync], &setter)
+        method_for(name, options[:sync], &getter)
+        alias_for("#{name}?", name, options[:sync]) if boolean
+      end
 
-    def _define(name, boolean, options, blocks = {})
-      setter = blocks[:setter] || lambda { sync_value(self[name] = val, options[:sync]) }
-      getter = blocks[:getter] || lambda { migrate_value(self[name], options[:from]) }
-      _default(name, options[:default])
-      _method("#{name}=", options[:sync], &setter)
-      _method(name, options[:sync], &getter)
-      _alias("#{name}?", name, options[:sync]) if boolean
-    end
+      def default_for(name, default)
+        @defaults[name.to_s] = default
+      end
 
-    def _default(name, default)
-      @defaults[name.to_s] = default
-    end
+      def log_warning(name, type, old_name)
+        message = <<-HEREDOC
+          Schemattr Warning: #{name}, #{type}, from: #{old_name}
+          You are using the keyword `from:` instead of the new `value_from:`. This is deprecated and will be removed in a future version."
+        HEREDOC
+        puts message
+      end
 
-    def _method(name, delegated = false, &block)
-      @delegated.push(name.to_s) if delegated
-      unless attribute_class.instance_methods.include?(name.to_sym)
-        attribute_class.send(:define_method, name, &block)
+      def method_for(name, delegated = false, &block)
+        @delegated.push(name.to_s) if delegated
+        unless attribute_class.instance_methods.include?(name.to_sym)
+          attribute_class.send(:define_method, name, &block)
+        end
       end
-    end
 
-    def _alias(new, old, delegated)
-      @delegated.push(new.to_s) if delegated
-      unless attribute_class.instance_methods.include?(new.to_sym)
-        attribute_class.send(:alias_method, new, old)
+      def alias_for(new, old, delegated)
+        @delegated.push(new.to_s) if delegated
+        attribute_class.send(:alias_method, new, old) unless attribute_class.instance_methods.include?(new.to_sym)
       end
-    end
   end
 end

data/lib/schemattr/version.rb

@@ -1,3 +1,17 @@
+# frozen_string_literal: true
+
 module Schemattr
-  VERSION = "0.0.1"
+  # Returns the currently loaded version as a +Gem::Version+.
+  def self.version
+    Gem::Version.new(VERSION::STRING)
+  end
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
 end

data/lib/schemattr.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "schemattr/version"
 require "schemattr/dsl"
 require "schemattr/attribute"
-require "schemattr/active_record_extension.rb"
+require "schemattr/active_record_extension"
 
 ActiveRecord::Base.send(:include, Schemattr::ActiveRecordExtension) if defined?(ActiveRecord)

metadata

@@ -1,34 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: schemattr
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
-- jejacks0n
-autorequire: 
+- Jeremy Jackson
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-11-16 00:00:00.000000000 Z
-dependencies: []
-description: ''
-email:
-- info@modeset.com
+date: 2023-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Write schema-less attributes in ActiveRecord using a helpful and flexible
+  DSL.
+email: jejacks0n@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT.LICENSE
+- CHANGELOG.md
+- MIT-LICENSE
 - README.md
 - lib/schemattr.rb
 - lib/schemattr/active_record_extension.rb
 - lib/schemattr/attribute.rb
 - lib/schemattr/dsl.rb
 - lib/schemattr/version.rb
-homepage: https://github.com/modeset/schemattr
+homepage: https://github.com/jejacks0n/schemattr
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/jejacks0n/schemattr
+  source_code_uri: https://github.com/jejacks0n/schemattr
+  bug_tracker_uri: https://github.com/jejacks0n/schemattr/issues
+  changelog_uri: https://github.com/jejacks0n/schemattr/CHANGELOG.md
+  documentation_uri: https://github.com/jejacks0n/schemattr/README.md
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -36,16 +57,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.4.14
+signing_key:
 specification_version: 4
-summary: ''
+summary: 'Schemattr: Simple schema-less column definitions for ActiveRecord.'
 test_files: []