schemattr 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3162b47b2a1acf700ca81a8ee47222391cf0711ad4b5194b9d5c46cf19584162
-  data.tar.gz: 12b294d20e189e9d16bb23644a26199829bccd3c42ba1b7662aea33b79ae4662
+  metadata.gz: 4d2d2b02fcfc5238afd51f0741a619f334315e785b91c2add642cc1ef0955962
+  data.tar.gz: b586cd63d36d773027f6786b81c785eba67b4439a1f9999140e7bff4ad44eb4d
 SHA512:
-  metadata.gz: 1134ffee2611f6f203f3891fe21088121a80f7ceb6a02197dd8cf4aa97b114d575a82c6652217faafb840ecbf6dbf904d61169984ee3cf7fb499dcb035f1a2fe
-  data.tar.gz: dee2aa5f9b8120885f8a0422de822e5ced1bf60103668149963d8ce8866c535db0915123427968af0b3b85653fb18626540190bad2ca16120da5bd79c7385c26
+  metadata.gz: 6bd7afaa4e360c1efe3b171fe2815f2687c23aaf6f1243bdb162ad720788ffd531b2569bfc63e16cd35698a0ad52fdc80196518703651c02d4e7251fe985a59c
+  data.tar.gz: a59b2bd4c1f0bc29ba27d0859512fd863208f4b7591d4a951e67b60e2f80c4a6053fbd61b0598ef264798249ae84c3df4d51591ff9c18f24cc88ec23daee7bb3

data/MIT.LICENSE

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

data/README.md

@@ -2,17 +2,15 @@ Schemattr
 =========
 
 [![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)
+[![Build Status](https://img.shields.io/travis/jejacks0n/schemattr.svg)](https://travis-ci.org/jejacks0n/schemattr)
+[![Code Climate](https://codeclimate.com/github/jejacks0n/schemattr/badges/gpa.svg)](https://codeclimate.com/github/jejacks0n/schemattr)
+[![Test Coverage](https://codeclimate.com/github/jejacks0n/schemattr/badges/coverage.svg)](https://codeclimate.com/github/jejacks0n/schemattr)
+[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)
 
 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.
 
 ### Background
-
 Let's say you have a User model, and that model has a simple concept of settings -- just one for now. It's a boolean
 named `opted_in`, and it means that the user is opted in to receive email updates. Sweet, we go add a migration for this
 setting and migrate. Ship it, we're done with that feature.
@@ -34,39 +32,12 @@ 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.
 
-
-## 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)
-
-
 ## Installation
-
-Add it to your Gemfile:
 ```ruby
-gem 'schemattr'
-```
-
-And then execute:
-```shell
-$ bundle
-```
-
-Or install it yourself as:
-```shell
-$ gem install schemattr
+gem "schemattr"
 ```
 
-
 ## Usage
-
 In the examples we assume there's already a User model and table.
 
 First, let's create a migration to add your schema-less attribute. In postgres you can use a JSON column. We use the
@@ -113,7 +84,6 @@ when they're persisted they'll include whatever we've changed them to be. If we
 they'll just be the defaults if we ever ask again.
 
 ### Field types
-
 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.
 
@@ -135,14 +105,13 @@ field is set -- this is intended for when you need something that doesn't care w
 harder to use in forms however.
 
 ### Delegating
-
 If you don't like the idea of having to access these attributes at `user.settings` you can specify that you'd like them
 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
@@ -153,7 +122,6 @@ user.opted_in? # => false
 ```
 
 ### Strict mode vs. arbitrary fields
-
 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.
 
@@ -161,9 +129,9 @@ allows any arbitrary field to be set or asked for.
 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
@@ -175,7 +143,6 @@ user.foo # => NoMethodError
 ```
 
 ### Overriding
-
 Schemattr provides the ability to specify your own attribute class. By doing so you can provide your own getters and
 setters and do more complex logic. In this example we're providing the inverse of `opted_in` with an `opted_out` psuedo
 field.
@@ -188,15 +155,15 @@ class UserSettings < Schemattr::Attribute
   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
@@ -211,7 +178,6 @@ Our custom `opted_out` psuedo field won't be persisted, because it's not a defin
 existing field that is persisted (`opted_in`).
 
 #### Getters and setters
-
 When overriding the attribute class with your own, you can provide your own custom getters and setters as well. These
 will not be overridden by whatever Schemattr thinks they should do. Take this example, where when someone turns on or
 off a setting we want to subscribe/unsubscribe them to an email list via a third party.
@@ -233,17 +199,16 @@ end
 *Note*: This is not a real world scenario but serves our purposes of describing an example. 
 
 ### Renaming fields
-
 Schemattr makes it easy to rename fields as well. Let's say you've got a field named `opted_in`, as the examples have
 shown thus far. But you've added new email lists, and you think `opted_in` is too vague. Like, opted in for what?
 
 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, 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
@@ -260,9 +225,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,9 +246,7 @@ 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
 have a JSON column in postgres, you can query values from within that column in various ways.
 
@@ -295,13 +258,9 @@ User.where("(settings->>'opted_in')::boolean") # boolean query
 User.where("settings->>'string_value' = ?", "some string") # string query 
 ```
 
-
 ## License
+Licensed under the [MIT License](http://creativecommons.org/licenses/MIT/)
 
-Licensed under the [MIT License](http://creativecommons.org/licenses/MIT)
-
-Copyright 2015 [Mode Set](https://github.com/modeset)
-
+Copyright 2019 [jejacks0n](https://github.com/jejacks0n)
 
 ## Make Code Not War
-![crest](https://secure.gravatar.com/avatar/aa8ea677b07f626479fd280049b0e19f?s=75)

data/lib/schemattr/active_record_extension.rb

@@ -23,7 +23,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 +33,14 @@ 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

@@ -23,38 +23,38 @@ module Schemattr
 
     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}"
+      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
-    end
 
-    def migrate_value(val, from)
-      return val unless from
-      if (old_val = self[from]).nil?
-        val
-      else
-        @hash.delete(from.to_s)
-        old_val
+      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 sync_value(val, to)
-      model[to] = val if to
-      val
-    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

@@ -14,73 +14,71 @@ module Schemattr
 
     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 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[:from]) }
-      _default(name, options[:default])
-      _method("#{name}=", options[:sync], &setter)
-      _method(name, options[:sync], &getter)
-      _alias("#{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_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 _default(name, default)
-      @defaults[name.to_s] = default
-    end
+      def default_for(name, default)
+        @defaults[name.to_s] = default
+      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,3 @@
 module Schemattr
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: schemattr
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - jejacks0n
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-16 00:00:00.000000000 Z
+date: 2019-04-14 00:00:00.000000000 Z
 dependencies: []
-description: ''
+description: Write schema-less attributes in ActiveRecord using a helpful and flexible
+  DSL.
 email:
-- info@modeset.com
+- jejacks0n@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -24,7 +25,7 @@ files:
 - lib/schemattr/attribute.rb
 - lib/schemattr/dsl.rb
 - lib/schemattr/version.rb
-homepage: https://github.com/modeset/schemattr
+homepage: http://github.com/jejacks0n/bitbot
 licenses:
 - MIT
 metadata: {}
@@ -34,9 +35,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -47,5 +48,5 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: ''
+summary: 'Schemattr: Simple schema-less column definitions for ActiveRecord'
 test_files: []