attr_json 0.2.0 → 1.5.0

data/lib/attr_json/record.rb

@@ -17,21 +17,83 @@ module AttrJson
   module Record
     extend ActiveSupport::Concern
 
-    DEFAULT_CONTAINER_ATTRIBUTE = :json_attributes
-
     included do
-      unless self < ActiveRecord::Base
+      unless self <= ActiveRecord::Base
         raise TypeError, "AttrJson::Record can only be used with an ActiveRecord::Base model. #{self} does not appear to be one. Are you looking for ::AttrJson::Model?"
       end
 
       class_attribute :attr_json_registry, instance_accessor: false
       self.attr_json_registry = AttrJson::AttributeDefinition::Registry.new
+    end
 
-      class_attribute :default_json_container_attribute, instance_acessor: false
-      self.default_json_container_attribute ||= DEFAULT_CONTAINER_ATTRIBUTE
+    protected
+
+    # adapted from ActiveRecord query_attribute method
+    # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/attribute_methods/query.rb#L12
+    #
+    # Sadly we could not re-use Rails code here, becuase the built-in method assumes attribute
+    # can be obtained with `self[attr_name]`, which you can not with attr_json (is that bad?), as
+    # well as `self.class.columns_hash[attr_name]` which you definitely can not (which is probably not bad),
+    # and has no way to use the value-translation semantics independently of that. May be a problem if
+    # ActiveRecord changes it's query method semantics in the future, will have to be sync'd here.
+    #
+    # Used to implement query methods on attr_json attributes, like `attr_json :foo, :string`, method `#foo?`
+    def self.attr_json_query_method(record, attribute)
+      value = record.send(attribute)
+
+      case value
+      when true
+        true
+      when false, nil, ActiveModel::Type::Boolean::FALSE_VALUES
+        false
+      else
+        if value.respond_to?(:to_i) && ( Numeric === value || value.to_s !~ /[^0-9]/ )
+          !value.to_i.zero?
+        elsif value.respond_to?(:zero?)
+          !value.zero?
+        else
+          !value.blank?
+        end
+      end
     end
 
     class_methods do
+      # Access or set class-wide json_attribute_config. Inherited by sub-classes,
+      # but setting on sub-classes is unique to subclass. Similar to how
+      # rails class_attribute's are used.
+      #
+      # @example access config
+      #   SomeClass.attr_json_config
+      #
+      # @example set config variables
+      #    class SomeClass < ActiveRecordBase
+      #       include JsonAttribute::Record
+      #
+      #       attr_json_config(default_container_attribute: "some_column")
+      #    end
+      # TODO make Model match please.
+      def attr_json_config(new_values = {})
+        if new_values.present?
+          # get one without new values, then merge new values into it, and
+          # set it locally for this class.
+          @attr_json_config = attr_json_config.merge(new_values)
+        else
+          if instance_variable_defined?("@attr_json_config")
+            # we have a custom one for this class, return it.
+            @attr_json_config
+          elsif superclass.respond_to?(:attr_json_config)
+            # return superclass without setting it locally, so changes in superclass
+            # will continue effecting us.
+            superclass.attr_json_config
+          else
+            # no superclass, no nothing, set it to blank one.
+            @attr_json_config = Config.new(mode: :record)
+          end
+        end
+      end
+
+
+
       # Type can be a symbol that will be looked up in `ActiveModel::Type.lookup`,
       # or an ActiveModel:::Type::Value).
       #
@@ -47,9 +109,9 @@ module AttrJson
       # @option options [String,Symbol] :store_key (nil) Serialize to JSON using
       #   given store_key, rather than name as would be usual.
       #
-      # @option options [Symbol,String] :container_attribute (self.default_json_container_attribute) The real
+      # @option options [Symbol,String] :container_attribute (attr_json_config.default_container_attribute, normally `json_attributes`) The real
       #   json(b) ActiveRecord attribute/column to serialize as a key in. Defaults to
-      #  `self.default_json_container_attribute`, which defaults to `:attr_jsons`
+      #  `attr_json_config.default_container_attribute`, which defaults to `:json_attributes`
       #
       # @option options [Boolean] :validate (true) Create an ActiveRecord::Validations::AssociatedValidator so
       #   validation errors on the attributes post up to self.
@@ -57,14 +119,16 @@ module AttrJson
       # @option options [Boolean] :rails_attribute (false) Create an actual ActiveRecord
       #    `attribute` for name param. A Rails attribute isn't needed for our functionality,
       #    but registering thusly will let the type be picked up by simple_form and
-      #    other tools that may look for it via Rails attribute APIs.
+      #    other tools that may look for it via Rails attribute APIs. Default can be changed
+      #    with `attr_json_config(default_rails_attribute: true)`
       def attr_json(name, type, **options)
         options = {
-          rails_attribute: false,
+          rails_attribute: self.attr_json_config.default_rails_attribute,
           validate: true,
-          container_attribute: self.default_json_container_attribute
+          container_attribute: self.attr_json_config.default_container_attribute,
+          accepts_nested_attributes: self.attr_json_config.default_accepts_nested_attributes
         }.merge!(options)
-        options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :rails_attribute])
+        options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :rails_attribute, :accepts_nested_attributes])
         container_attribute = options[:container_attribute]
 
         # TODO arg check container_attribute make sure it exists. Hard cause
@@ -74,13 +138,19 @@ module AttrJson
         # only if it hasn't already been done. WARNING we are using internal
         # Rails API here, but only way to do this lazily, which I thought was
         # worth it. On the other hand, I think .attribute is idempotent, maybe we don't need it...
+        #
+        # We set default to empty hash, because that 'tricks' AR into knowing any
+        # application of defaults is a change that needs to be saved.
         unless attributes_to_define_after_schema_loads[container_attribute.to_s] &&
-               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute)
-            attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute)
+               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute) &&
+               attributes_to_define_after_schema_loads[container_attribute.to_s].first.model == self
+           # If this is already defined, but was for superclass, we need to define it again for
+           # this class.
+           attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute), default: -> { {} }
         end
 
         self.attr_json_registry = attr_json_registry.with(
-          AttributeDefinition.new(name.to_sym, type, options.except(:rails_attribute, :validate))
+          AttributeDefinition.new(name.to_sym, type, options.except(:rails_attribute, :validate, :accepts_nested_attributes))
         )
 
         # By default, automatically validate nested models
@@ -91,36 +161,54 @@ module AttrJson
         # We don't actually use this for anything, we provide our own covers. But registering
         # it with usual system will let simple_form and maybe others find it.
         if options[:rails_attribute]
-          self.attribute name.to_sym, self.attr_json_registry.fetch(name).type
+          attr_json_definition = attr_json_registry[name]
+
+          attribute_args = attr_json_definition.has_default? ? { default: attr_json_definition.default_argument } : {}
+          self.attribute name.to_sym, attr_json_definition.type, **attribute_args
+
+          # Ensure that rails attributes tracker knows about value we just fetched
+          # for this particular attribute. Yes, we are registering an after_find for each
+          # attr_json registered with rails_attribute:true, using the `name` from above under closure. .
+          after_find do
+            value = public_send(name)
+            if value && has_attribute?(name.to_sym)
+              write_attribute(name.to_sym, value)
+              self.send(:clear_attribute_changes, [name.to_sym])
+            end
+          end
         end
 
         _attr_jsons_module.module_eval do
+          # For getter and setter, we used to use read_store_attribute/write_store_attribute
+          # copied from Rails store_accessor implementation.
+          # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+          #
+          # But in fact just getting/setting in the hash provided to us by ActiveRecord json type
+          # container works BETTER for dirty tracking. We had a test that only passed doing it
+          # this simple way.
+
           define_method("#{name}=") do |value|
+            super(value) if defined?(super)
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
-            # write_store_attribute copied from Rails store_accessor implementation.
-            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-
-            # special handling for nil, sorry, because if name key was previously
-            # not present, write_store_attribute by default will decide there was
-            # no change and refuse to make the change. TODO messy.
-            if value.nil? && !public_send(attribute_def.container_attribute).has_key?(attribute_def.store_key)
-               public_send :"#{attribute_def.container_attribute}_will_change!"
-               public_send(attribute_def.container_attribute)[attribute_def.store_key] = nil
-            else
-              # use of `write_store_attribute` is copied from Rails store_accessor implementation.
-              # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-              write_store_attribute(attribute_def.container_attribute, attribute_def.store_key, attribute_def.cast(value))
-            end
+            public_send(attribute_def.container_attribute)[attribute_def.store_key] = attribute_def.cast(value)
           end
 
           define_method("#{name}") do
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
+            public_send(attribute_def.container_attribute)[attribute_def.store_key]
+          end
 
-            # use of `read_store_attribute` is copied from Rails store_accessor implementation.
-            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-            read_store_attribute(attribute_def.container_attribute, attribute_def.store_key)
+          define_method("#{name}?") do
+            # implementation of `query_store_attribute` is based on Rails `query_attribute` implementation
+            AttrJson::Record.attr_json_query_method(self, name)
           end
         end
+
+        # Default attr_json_accepts_nested_attributes_for values
+        if options[:accepts_nested_attributes]
+          options = options[:accepts_nested_attributes] == true ? {} : options[:accepts_nested_attributes]
+          self.attr_json_accepts_nested_attributes_for name, **options
+        end
       end
 
       private

data/lib/attr_json/serialization_coder_from_type.rb

@@ -0,0 +1,40 @@
+module AttrJson
+
+  # A little wrapper to provide an object that provides #dump and #load method for use
+  # as a coder second-argument for [ActiveRecord Serialization](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html),
+  # that simply delegates to #serialize and #deserialize from a ActiveModel::Type object.
+  #
+  # Created to be used with an AttrJson::Model type (AttrJson::Type::Model), but hypothetically
+  # could be a shim from anything with serialize/deserialize to dump/load instead.
+  #
+  #    class ValueModel
+  #      include AttrJson::Model
+  #      attr_json :some_string, :string
+  #    end
+  #
+  #    class SomeModel < ApplicationRecord
+  #      serialize :some_json_column, ValueModel.to_serialize_coder
+  #    end
+  #
+  # Note when used with an AttrJson::Model, it will dump/load from a HASH, not a
+  # string. It assumes it's writing to a Json(b) column that wants/provides hashes,
+  # not strings.
+  class SerializationCoderFromType
+    attr_reader :type
+    def initialize(type)
+      @type = type
+    end
+
+    # Dump and load methods to support ActiveRecord Serialization
+    # too.
+    def dump(value)
+      type.serialize(value)
+    end
+
+    # Dump and load methods to support ActiveRecord Serialization
+    # too. https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html
+    def load(value)
+      type.deserialize(value)
+    end
+  end
+end

data/lib/attr_json/type/array.rb

@@ -41,6 +41,12 @@ module AttrJson
         ]
       end
 
+      # Hacky, hard-coded classes, but used in our weird primitive implementation in NestedAttributes,
+      # better than putting the conditionals there
+      def base_type_primitive?
+        !(base_type.is_a?(AttrJson::Type::Model) || base_type.is_a?(AttrJson::Type::PolymorphicModel))
+      end
+
       protected
       def convert_to_array(value)
         if value.kind_of?(Hash)

data/lib/attr_json/type/container_attribute.rb

@@ -38,19 +38,30 @@ module AttrJson
           [key, attr_def ? attr_def.serialize(value) : value]
         end.to_h)
       end
-      def deserialize(v)
-        h = super || {}
+
+      # optional with_defaults arg is our own, not part of ActiveModel::Type API,
+      # used by {#changed_in_place?} so we can consider default application to
+      # be a change.
+      def deserialize(v, with_defaults: true)
+        h = super(v) || {}
         model.attr_json_registry.definitions.each do |attr_def|
           next unless container_attribute.to_s == attr_def.container_attribute.to_s
 
           if h.has_key?(attr_def.store_key)
             h[attr_def.store_key] = attr_def.deserialize(h[attr_def.store_key])
-          elsif attr_def.has_default?
+          elsif with_defaults && attr_def.has_default?
             h[attr_def.store_key] = attr_def.provide_default!
           end
         end
         h
       end
+
+      # Just like superclass, but we tell deserialize to NOT apply defaults,
+      # so we can consider default-application to be a change.
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value, with_defaults: false) != new_value
+      end
+
     end
   end
 end

data/lib/attr_json/type/model.rb

@@ -7,7 +7,10 @@ module AttrJson
     # You create one with AttrJson::Model::Type.new(attr_json_model_class),
     # but normally that's only done in AttrJson::Model.to_type, there isn't
     # an anticipated need to create from any other place.
+    #
     class Model < ::ActiveModel::Type::Value
+      class BadCast < ArgumentError ; end
+
       attr_accessor :model
       def initialize(model)
         #TODO type check, it really better be a AttrJson::Model. maybe?
@@ -29,15 +32,18 @@ module AttrJson
           # to_hash is actually the 'implicit' conversion, it really is a hash
           # even though it isn't is_a?(Hash), try to_hash first before to_h,
           # the explicit conversion.
-          model.new_from_serializable(v.to_hash)
+          model.new(v.to_hash)
         elsif v.respond_to?(:to_h)
           # TODO Maybe we ought not to do this on #to_h?
-          model.new_from_serializable(v.to_h)
-        else
-          # Bad input? Most existing ActiveModel::Types seem to decide
-          # either nil, or a base value like the empty string. They don't
-          # raise. So we won't either, just nil.
+          model.new(v.to_h)
+        elsif model.attr_json_config.bad_cast == :as_nil
+          # This was originally default behavior, to be like existing ActiveRecord
+          # which kind of silently does this for non-castable basic values. That
+          # ended up being confusing in the basic case, so now we raise by default,
+          # but this is still configurable.
           nil
+        else
+          raise BadCast.new("Can not cast from #{v.inspect} to #{self.type}")
         end
       end
 
@@ -47,12 +53,36 @@ module AttrJson
         elsif v.kind_of?(model)
           v.serializable_hash
         else
-          cast(v).serializable_hash
+          (cast_v = cast(v)) && cast_v.serializable_hash
         end
       end
 
       def deserialize(v)
-        cast(v)
+        if v.nil?
+          # important to stay nil instead of empty object, because they
+          # are different things.
+          v
+        elsif v.kind_of? model
+          v
+        elsif v.respond_to?(:to_hash)
+          # to_hash is actually the 'implicit' conversion, it really is a hash
+          # even though it isn't is_a?(Hash), try to_hash first before to_h,
+          # the explicit conversion.
+          model.new_from_serializable(v.to_hash)
+        elsif v.respond_to?(:to_h)
+          # TODO Maybe we ought not to do this on #to_h? especially here in deserialize?
+          model.new_from_serializable(v.to_h)
+        elsif model.attr_json_config.bad_cast == :as_nil
+          # TODO should we have different config value for bad_deserialize vs bad_cast?
+
+          # This was originally default behavior, to be like existing ActiveRecord
+          # which kind of silently does this for non-castable basic values. That
+          # ended up being confusing in the basic case, so now we raise by default,
+          # but this is still configurable.
+          nil
+        else
+          raise BadCast.new("Can not cast from #{v.inspect} to #{self.type}")
+        end
       end
 
       # these guys are definitely mutable, so we need this.

data/lib/attr_json/type/polymorphic_model.rb

@@ -51,6 +51,8 @@ module AttrJson
     #      MyRecord.jsonb_contains(author: { name: "foo", type: "Corporation"})
     #      MyRecord.jsonb_contains(author: Corporation.new(name: "foo"))
     #
+    # Additionally, there is not_jsonb_contains, which creates the same query terms like jsonb_contains, but negated.
+    #
     class PolymorphicModel < ActiveModel::Type::Value
       class TypeError < ::TypeError ; end
 
@@ -112,6 +114,11 @@ module AttrJson
       end
 
       def serialize(v)
+        return nil if v.nil?
+
+        # if it's not already a model cast it to a model if possible (eg it's a hash)
+        v = cast(v)
+
         model_name = v.class.name
         type = type_for_model_name(model_name)
 

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "0.2.0"
+  VERSION = "1.5.0"
 end

data/lib/attr_json.rb

@@ -1,8 +1,8 @@
 require "attr_json/version"
 
 require "active_record"
-require "active_record/connection_adapters/postgresql_adapter"
 
+require 'attr_json/config'
 require 'attr_json/record'
 require 'attr_json/model'
 require 'attr_json/nested_attributes'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Jonathan Rochkind
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-05-04 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,30 +64,44 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: yard-activesupport-concern
+  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: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: yard-activesupport-concern
+  name: rexml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -100,6 +114,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: |-
   ActiveRecord attributes stored serialized in a json column, super smooth.
   For Rails 5.0, 5.1, or 5.2. Typed and cast like Active Record. Supporting nested models,
@@ -114,10 +142,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
+- ".github/workflows/future_rails_ci.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - ".yardopts"
+- Appraisals
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -130,9 +161,18 @@ files:
 - config.ru
 - doc_src/dirty_tracking.md
 - doc_src/forms.md
+- gemfiles/.bundle/config
+- gemfiles/rails_5_0.gemfile
+- gemfiles/rails_5_1.gemfile
+- gemfiles/rails_5_2.gemfile
+- gemfiles/rails_6_0.gemfile
+- gemfiles/rails_6_1.gemfile
+- gemfiles/rails_7_0.gemfile
+- gemfiles/rails_edge.gemfile
 - lib/attr_json.rb
 - lib/attr_json/attribute_definition.rb
 - lib/attr_json/attribute_definition/registry.rb
+- lib/attr_json/config.rb
 - lib/attr_json/model.rb
 - lib/attr_json/model/cocoon_compat.rb
 - lib/attr_json/nested_attributes.rb
@@ -143,6 +183,7 @@ files:
 - lib/attr_json/record/dirty.rb
 - lib/attr_json/record/query_builder.rb
 - lib/attr_json/record/query_scopes.rb
+- lib/attr_json/serialization_coder_from_type.rb
 - lib/attr_json/type/array.rb
 - lib/attr_json/type/container_attribute.rb
 - lib/attr_json/type/model.rb
@@ -155,7 +196,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/jrochkind/attr_json
   source_code_uri: https://github.com/jrochkind/attr_json
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -163,16 +204,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
-signing_key: 
+rubygems_version: 3.2.33
+signing_key:
 specification_version: 4
 summary: ActiveRecord attributes stored serialized in a json column, super smooth.
 test_files: []

data/.travis.yml

@@ -1,17 +0,0 @@
-#
-dist: trusty
-sudo: false
-addons:
-  postgresql: '9.4'
-  chrome: stable
-language: ruby
-cache: bundler
-rvm:
-  - 2.4
-  - 2.5.0
-env:
-  - RAILS_GEM="~> 5.0.0" PG_GEM="~> 0.18"
-  - RAILS_GEM="~> 5.1.0"
-  - RAILS_GEM=">= 5.2.0.rc2,< 5.3.0"
-before_install:
-  - gem install bundler -v 1.14.6