sequel-enhancements 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2840f32e514ff77d17e198107a31d70b8d5e6759
+  data.tar.gz: 29237adc425e5bbc447c0156e77bab590f7b0d79
+SHA512:
+  metadata.gz: 0bd03fced0217c9f652c1d51313c974dd2bf63a9c79cf04cfa4330772503390944e520476dd4989bedf77f13f345d0500921712ec996e8c8ebe7f69a3c841fd1
+  data.tar.gz: f7e1af7cd2920d737dc2300312bbc91156a97a8f90c0195a4a37ffabec7d266585fde2e76c80d233e84b321f3e942f70e10708d261096b0e75ea3167cc09a437

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/bundle

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 peer60
+
+MIT License
+
+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,48 @@
+# Sequel::Enhancements
+
+peer60 plugins and extensions for [Sequel](http://sequel.jeremyevans.net/)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sequel-enhancements'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sequel-enhancements
+
+## Usage
+
+Require plugins and extensions as normal
+
+```ruby
+Sequel::Model.plugin :string_nilifier
+```
+
+## Included plugins
+
+- `hash_cleaner` strips trailing and leading invisibles from 
+- `string_cleaner` a stronger version of `string_stripper`, removing all invisibles
+- `string_downcaser` force downcasing of specified columns
+- `string_nilifier` sets empty strings to nil
+- `string_upcaser` force upcasing of specified columns
+
+## Included extensions
+
+- `sqlite_json` json support for SQLite
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sequel-enhancements/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs = ['spec', 'lib']
+  t.pattern = 'spec/**/*_spec.rb'
+end
+

data/lib/sequel/enhancements.rb

@@ -0,0 +1,17 @@
+require "sequel/enhancements/version"
+
+module Sequel
+  module Enhancements
+    extend self
+    SURROUNDING_INVISIBLES = /\A[^[:graph:]]+|[^[:graph:]]+\z/.freeze
+
+
+    def trim_invisible(str)
+      if str.is_a?(String) && !str.is_a?(SQL::Blob)
+        str.gsub(SURROUNDING_INVISIBLES, '')
+      else
+        str
+      end
+    end
+  end
+end

data/lib/sequel/enhancements/version.rb

@@ -0,0 +1,5 @@
+module Sequel
+  module Enhancements
+    VERSION = "0.2.0"
+  end
+end

data/lib/sequel/extensions/sqlite_json.rb

@@ -0,0 +1,93 @@
+module Sequel
+  module SQLite
+    class JSONArray < DelegateClass(Array)
+      include Sequel::SQL::AliasMethods
+
+      # Convert the array to a json string, append a
+      # literalized version of the string to the sql, and explicitly
+      # cast the string to json.
+      def sql_literal_append(ds, sql)
+        ds.literal_append(sql, Sequel.object_to_json(self))
+      end
+    end
+
+    class JSONHash < DelegateClass(Hash)
+      include Sequel::SQL::AliasMethods
+
+      # Convert the hash to a json string, append a
+      # literalized version of the string to the sql, and explicitly
+      # cast the string to json.
+      def sql_literal_append(ds, sql)
+        ds.literal_append(sql, Sequel.object_to_json(self))
+      end
+
+      # Return the object being delegated to.
+      alias to_hash __getobj__
+    end
+
+    module DatabaseMethods
+      JSON_TYPES = %w{
+        json varchar[] text[] integer[] int[] boolean[] money[]
+      }.map(&:freeze).freeze
+
+      def self.extended(db)
+        procs = db.conversion_procs
+        parse_method = method :db_parse_json
+        JSON_TYPES.each do |type|
+          procs[type] = parse_method
+        end
+      end
+
+      def self.db_parse_json(s)
+        parse_json(s)
+      rescue Sequel.json_parser_error_class => e
+        raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+      end
+
+      def self.parse_json(s)
+        begin
+          value = Sequel.parse_json(s)
+        rescue Sequel.json_parser_error_class => e
+          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+        end
+
+        case value
+        when Array
+          JSONArray.new(value)
+        when Hash
+          JSONHash.new(value)
+        else
+          raise Sequel::InvalidValue, "unhandled json value: #{value.inspect} (from #{s.inspect})"
+        end
+      end
+
+      def schema_column_type(db_type)
+        case db_type
+        when 'json'
+          'json'
+        when /\[\]$/
+          'json'
+        else
+          super
+        end
+      end
+
+      def typecast_value_json(value)
+        case value
+        when JSONArray, JSONHash
+          value
+        when Array
+          JSONArray.new(value)
+        when Hash
+          JSONHash.new(value)
+        when String
+          DatabaseMethods.parse_json(value)
+        else
+          raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
+        end
+      end
+    end
+  end
+
+  Database.register_extension :sqlite_json, SQLite::DatabaseMethods
+end

data/lib/sequel/plugins/hash_cleaner.rb

@@ -0,0 +1,34 @@
+require "sequel/enhancements"
+
+module Sequel
+  module Plugins
+    module HashCleaner
+      SURROUNDING_INVISIBLES = /\A[^[:graph:]]+|[^[:graph:]]+\z/.freeze
+
+      def self.apply(model, *args)
+        model.plugin(:input_transformer, :hash_cleaner){ |v| v.is_a?(Hash) ? clean(v) : v }
+      end
+
+      private
+
+      def self.clean(value)
+        if value.is_a?(Hash)
+          value.each_with_object({}) do |(k, v), memo|
+            cleaned = clean v
+            memo[k] = cleaned unless exclude?(cleaned)
+          end
+        else
+          Sequel::Enhancements.trim_invisible(value)
+        end
+      end
+
+      def self.clean_value(value)
+        value.is_a?(String) ? value.trim_invisible : value
+      end
+
+      def self.exclude?(value)
+        value.nil? || (value.is_a?(String) && value.empty?)
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_cleaner.rb

@@ -0,0 +1,13 @@
+require "sequel/enhancements"
+
+module Sequel
+  module Plugins
+    module StringCleaner
+      def self.apply(model, *args)
+        model.plugin(:input_transformer, :string_cleaner) do |v|
+          Enhancements.trim_invisible(v)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_downcaser.rb

@@ -0,0 +1,38 @@
+require "sequel/enhancements"
+
+module Sequel
+  module Plugins
+    module StringDowncaser
+      def self.apply(model, *args)
+        model.instance_eval do
+          @downcase_columns = Set.new
+        end
+      end
+
+      def self.configure(model, column)
+        model.add_downcase_column column
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@downcase_columns => :dup)
+
+        def add_downcase_column(column)
+          @downcase_columns << column
+        end
+
+        def downcase_column?(column)
+          @downcase_columns.include? column
+        end
+      end
+
+      module InstanceMethods
+        def []=(k, v)
+          if model.downcase_column?(k) && v.is_a?(String) && !v.is_a?(SQL::Blob)
+            v = v.downcase
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_nilifier.rb

@@ -0,0 +1,38 @@
+require "sequel/enhancements"
+
+module Sequel
+  module Plugins
+    module StringNilifier
+      def self.apply(model)
+        model.plugin(:input_transformer, :string_nilifier) do |v|
+          (v.is_a?(String) && !v.is_a?(SQL::Blob) && v.empty?) ? nil : v
+        end
+      end
+
+      def self.configure(model)
+        model.instance_eval{set_skipped_string_nilifying_columns if @dataset}
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :set_skipped_string_nilifying_columns)
+
+        def skip_string_nilifying(*columns)
+          skip_input_transformer(:string_nilifier, *columns)
+        end
+
+        def skip_string_nilifying?(column)
+          skip_input_transformer?(:string_nilifier, column)
+        end
+
+        private
+
+        def set_skipped_string_nilifying_columns
+          if @db_schema
+            blob_columns = @db_schema.map{|k,v| k if v[:type] == :blob}.compact
+            skip_string_nilifying(*blob_columns)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_upcaser.rb

@@ -0,0 +1,38 @@
+require "sequel/enhancements"
+
+module Sequel
+  module Plugins
+    module StringUpcaser
+      def self.apply(model, *args)
+        model.instance_eval do
+          @upcase_columns = Set.new
+        end
+      end
+
+      def self.configure(model, column)
+        model.add_upcase_column column
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@upcase_columns => :dup)
+
+        def add_upcase_column(column)
+          @upcase_columns << column
+        end
+
+        def upcase_column?(column)
+          @upcase_columns.include? column
+        end
+      end
+
+      module InstanceMethods
+        def []=(k, v)
+          if model.upcase_column?(k) && v.is_a?(String) && !v.is_a?(SQL::Blob)
+            v = v.upcase
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/sequel-enhancements.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel/enhancements/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sequel-enhancements"
+  spec.version       = Sequel::Enhancements::VERSION
+  spec.authors       = ["peer60"]
+  spec.email         = ["development@peer60.com"]
+  spec.summary       = %q{Plugins and extensions for Sequel}
+  spec.description   = %q{Plugins and extensions for Sequel}
+  spec.homepage      = "https://bitbucket.org/peer60/sequel-enhancements"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "sequel"
+  spec.add_development_dependency "sqlite3"
+end

data/spec/extensions/sqlite_json_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'json'
+
+describe 'sqlite_json extension' do
+  let(:db){ Sequel.connect("sqlite:///") }
+  let(:model_class){ Class.new(Sequel::Model(db[:people])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    db.extension :sqlite_json
+    db.create_table(:people) do
+      primary_key :id
+      column :name, :text
+      column :address, :json
+      column :phones, 'text[]'
+      column :lucky_numbers, 'int[]'
+    end
+  end
+
+  it 'stores and retrieves json object' do
+    original = {'street' => '123 fake'}
+    subject.name = 'foo'
+    subject.address = original
+    subject.save
+    subject.address.must_equal original
+  end
+
+  it 'stores and retrieves arrays of strings' do
+    original = ['18008675309', '18005555555']
+    subject.phones = original
+    subject.save
+    subject.phones.must_equal original
+  end
+
+  it 'stores and retrieves arrays of ints' do
+    original = ['1','2','3']
+    subject.lucky_numbers = original
+    subject.save
+    subject.lucky_numbers.must_equal original
+  end
+end

data/spec/plugins/hash_cleaner_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Sequel::Plugins::HashCleaner' do
+  let(:db){ Sequel.mock }
+  let(:model_class){ Class.new(Sequel::Model(db[:test])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    model_class.columns :json_field, :other
+    model_class.plugin :hash_cleaner
+  end
+
+  after do
+    model_class.instance_variable_set :'@plugins', @previous_plugins
+  end
+
+  it 'clears nil' do
+    subject.json_field = {'value' => nil}
+    subject.json_field.must_equal({})
+  end
+
+  it 'clears empty word' do
+    subject.json_field = {'value' => ' '}
+    subject.json_field.must_equal({})
+  end
+
+  it 'cleans word' do
+    expected = 'something'
+    subject.json_field = {'value' => "\xC2\xA0 #{expected}\xC2\xA0 "}
+    subject.json_field.must_equal 'value' => expected
+  end
+
+  it 'doesnt touch inner characters' do
+    expected = "some \t \xC2\xA0 \n thing"
+    subject.json_field = {'value' => "\xC2\xA0 #{expected}\xC2\xA0 "}
+    subject.json_field.must_equal 'value' => expected
+  end
+
+  it 'doesnt affect falsy values' do
+    expected = 0
+    subject.json_field = {'value' => expected}
+    subject.json_field.must_equal 'value' => expected
+
+    expected = false
+    subject.json_field = {'value' => expected}
+    subject.json_field.must_equal 'value' => expected
+
+    expected = []
+    subject.json_field = {'value' => expected}
+    subject.json_field.must_equal 'value' => expected
+  end
+
+  it 'doesnt affect non-hash value' do
+    expected = " can't touch this "
+    subject.json_field = expected
+    subject.json_field.must_equal expected
+  end
+end

data/spec/plugins/string_cleaner_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'Sequel::Plugins::StringCleaner' do
+  let(:db){ Sequel.mock }
+  let(:model_class){ Class.new(Sequel::Model(db[:test])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    model_class.columns :name, :other
+    model_class.plugin :string_cleaner
+  end
+
+  it 'cleans word' do
+    expected = 'something'
+    subject.name = "\xC2\xA0 #{expected}\xC2\xA0 "
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt touch inner characters' do
+    expected = "some \t \xC2\xA0 \n thing"
+    subject.name = "\xC2\xA0 #{expected}\xC2\xA0 "
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt affect non-string inputs' do
+    expected = rand_i
+    subject.name = expected
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt blob alone' do
+    expected = Sequel.blob " #{rand_s} "
+    subject.name = expected
+    subject.name.must_be_instance_of Sequel::SQL::Blob
+    subject.name.must_equal expected
+  end
+end

data/spec/plugins/string_downcaser_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Sequel::Plugins::StringDowncaser' do
+  let(:db){ Sequel.mock }
+  let(:model_class){ Class.new(Sequel::Model(db[:test])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    model_class.columns :name, :other
+    model_class.plugin :string_downcaser, :name
+  end
+
+  it 'downcases specified column' do
+    expected = rand_s
+    subject.name = expected.upcase
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt affect unspecified columns' do
+    expected = rand_s.upcase
+    subject.other = expected
+    subject.other.must_equal expected
+  end
+
+  it 'handles nil value' do
+    subject.name = nil
+    subject.name.must_be_nil
+  end
+
+  it 'handles non-string value' do
+    subject.name = 7
+    subject.name.must_equal 7
+  end
+
+  it 'leaves blob alone' do
+    expected = Sequel.blob rand_s.upcase
+    subject.name = expected
+    subject.name.must_be_instance_of Sequel::SQL::Blob
+    subject.name.must_equal expected
+  end
+end

data/spec/plugins/string_nilifier_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'Sequel::Plugins::StringNilifier' do
+  let(:db){ Sequel.mock }
+  let(:model_class){ Class.new(Sequel::Model(db[:test])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    model_class.columns :name, :b
+    model_class.db_schema[:b][:type] = :blob
+    model_class.plugin :string_nilifier
+  end
+
+  it 'nilifies empty strings' do
+    subject.name = ''
+    subject.name.must_be_nil
+  end
+
+  it 'doesnt touch other fields' do
+    subject.name = 'hey'
+    subject.name.must_equal 'hey'
+
+    subject.name = 6
+    subject.name.must_equal 6
+  end
+
+  it 'doesnt affect blob arguments' do
+    expected = Sequel.blob('')
+    subject.name = expected
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt affect blob columns' do
+    model_class.must_be :skip_string_nilifying?, :b
+    subject.b = ''
+    subject.b.must_be_instance_of Sequel::SQL::Blob
+    subject.b.must_equal Sequel.blob('')
+  end
+
+  it 'allows skipping columns with Model.skip_string_nilifying' do
+    model_class.skip_string_nilifying :name
+    model_class.must_be :skip_string_nilifying?, :name
+    subject.name = ''
+    subject.name.must_equal ''
+  end
+
+end

data/spec/plugins/string_upcaser_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Sequel::Plugins::StringUpcaser' do
+  let(:db){ Sequel.mock }
+  let(:model_class){ Class.new(Sequel::Model(db[:test])){ @plugins.clear } }
+
+  subject { model_class.new }
+
+  before do
+    model_class.columns :name, :other
+    model_class.plugin :string_upcaser, :name
+  end
+
+  it 'upcases specified column' do
+    expected = rand_s.upcase
+    subject.name = expected.downcase
+    subject.name.must_equal expected
+  end
+
+  it 'doesnt affect unspecified columns' do
+    expected = rand_s.downcase
+    subject.other = expected
+    subject.other.must_equal expected
+  end
+
+  it 'handles nil value' do
+    subject.name = nil
+    subject.name.must_be_nil
+  end
+
+  it 'handles non-string value' do
+    subject.name = 7
+    subject.name.must_equal 7
+  end
+
+  it 'leaves blob alone' do
+    expected = Sequel.blob rand_s.downcase
+    subject.name = expected
+    subject.name.must_be_instance_of Sequel::SQL::Blob
+    subject.name.must_equal expected
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require "bundler/setup"
+require "sequel"
+require "minitest/autorun"
+
+class << Sequel::Model
+  attr_writer :db_schema
+  alias orig_columns columns
+  def columns(*cols)
+    return super if cols.empty?
+    define_method(:columns){cols}
+    @dataset.instance_variable_set(:@columns, cols) if @dataset
+    def_column_accessor(*cols)
+    @columns = cols
+    @db_schema = {}
+    cols.each{|c| @db_schema[c] = {}}
+  end
+end
+
+class Minitest::Spec
+  FIXNUM_MAX = 2**(0.size * 8 - 2)
+
+  def rand_s
+    SecureRandom.hex
+  end
+
+  def rand_i(max=FIXNUM_MAX)
+    SecureRandom.random_number(max)
+  end
+end
+
+class CustomFilter
+  def self.filter(bt)
+    return ['No backtrace'] unless bt
+
+    new_bt = bt.take_while { |line| line !~ %r{minitest} }
+    new_bt = bt.select     { |line| line !~ %r{minitest} } if new_bt.empty?
+    new_bt = bt.dup if new_bt.empty?
+
+    new_bt
+  end
+end
+
+Minitest.backtrace_filter = CustomFilter

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: sequel-enhancements
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- peer60
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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'
+description: Plugins and extensions for Sequel
+email:
+- development@peer60.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sequel/enhancements.rb
+- lib/sequel/enhancements/version.rb
+- lib/sequel/extensions/sqlite_json.rb
+- lib/sequel/plugins/hash_cleaner.rb
+- lib/sequel/plugins/string_cleaner.rb
+- lib/sequel/plugins/string_downcaser.rb
+- lib/sequel/plugins/string_nilifier.rb
+- lib/sequel/plugins/string_upcaser.rb
+- sequel-enhancements.gemspec
+- spec/extensions/sqlite_json_spec.rb
+- spec/plugins/hash_cleaner_spec.rb
+- spec/plugins/string_cleaner_spec.rb
+- spec/plugins/string_downcaser_spec.rb
+- spec/plugins/string_nilifier_spec.rb
+- spec/plugins/string_upcaser_spec.rb
+- spec/spec_helper.rb
+homepage: https://bitbucket.org/peer60/sequel-enhancements
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Plugins and extensions for Sequel
+test_files:
+- spec/extensions/sqlite_json_spec.rb
+- spec/plugins/hash_cleaner_spec.rb
+- spec/plugins/string_cleaner_spec.rb
+- spec/plugins/string_downcaser_spec.rb
+- spec/plugins/string_nilifier_spec.rb
+- spec/plugins/string_upcaser_spec.rb
+- spec/spec_helper.rb