sinja-sequel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f7b795742fcfdbe13930f92bd6946f3de0d89ed
+  data.tar.gz: c12983f2a42794564b744ecfef193c84f6ef064e
+SHA512:
+  metadata.gz: d619607435ab470cef5837a7603d0b60845ef346133962d1332f9a29d1eb48961a959449c865f94b7fb179909d10a2a0935c0401490801ee7ffdf6d2cb7b4f24
+  data.tar.gz: 129a26fe0d65b9a69c886c010202229bb6a11603aee4348e119c2ef71372dbdf7c69bae15ee10fc3c2066f9049e75750374a384ef4bf7ab563eb0841de36213d

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'sinja', :require=>false, :path=>'../..'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Mike Pastore
+
+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,274 @@
+# Sinja::Sequel
+
+<!--
+  Title: Sinja::Sequel
+  Description: Sequel-specific Helpers and DSL for Sinja
+  Author: Mike Pastore
+  Keywords: Ruby, Sinatra, Sinatra::JSONAPI, Sinja, Sequel
+  -->
+
+[![Gem Version](https://badge.fury.io/rb/sinja-sequel.svg)](https://badge.fury.io/rb/sinja-sequel)
+
+Sinja::Sequel configures your [Sinja][1] application to work with [Sequel][2]
+out of the box, and provides additional helpers to greatly simplify the process
+of writing the more complex action helpers (specifically `replace`, `merge`,
+and `subtract`). An optional extension enhances Sinja's DSL to generate basic
+action helpers that can be overridden, customized, or removed.
+
+The core configuration and helpers are in pretty good shape (Sinja uses them in
+its [demo app][3] and test suite), but the extension could use some fleshing
+out. Testers and community contributions welcome!
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Core](#core)
+  - [Helpers](#helpers)
+    - [`next_pk`](#next_pk)
+    - [`add_missing`](#add_missing)
+    - [`remove_present`](#remove_present)
+    - [`add_remove`](#add_remove)
+  - [Extension](#extension)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sinja-sequel'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install sinja-sequel
+```
+
+## Usage
+
+Always return Sequel datasets (instead of arrays of objects) from your `index`
+(e.g. `Foo.dataset`) and `fetch` (e.g.  `resource.bars_dataset`) action
+helpers. The `finalize` helper, described below, will ensure they are
+"rasterized" before being passed to [JSONAPI::Serializers][5].
+
+You'll want to enable Sequel's `:tactical_eager_loading` plugin for the best
+performance with JSONAPI::Serializers. I've [seen][6] it reduce complex
+serializations by a factor of 100 (i.e. quite literally one query instead of
+100).
+
+If you want to use client-generated IDs, enable the `:update_primary_key`
+plugin on the model and call `unrestrict_primary_key` in the model definition
+to allow mass assignment (e.g. with `Sequel::Model#set_fields`).
+
+If your model has foreign keys and you want to enforce a non-nullable
+constraint at the application level, consider enabling the
+`:validation_helpers` plugin on the model and using `validates_not_null` in
+conjuction with the `validate!` helper described below:
+
+```ruby
+class Bar < Sequel::Model
+  plugin :validation_helpers
+
+  def validate
+    super
+    validates_not_null :foo
+  end
+end
+```
+
+See "Avoding Null Foreign Keys" in the [Sinja][1] documentation for more
+information.
+
+Finally, enable the `:pagination` extension on your connection (before
+prepending Core) to enable pagination!
+
+### Core
+
+Prepend [Sinja::Sequel::Core](/extensions/sequel/lib/sinja/sequel/core.rb)
+after registering Sinja:
+
+```ruby
+require 'sinja'
+require 'sinja/sequel/core'
+
+class MyApp < Sinatra::Base
+  register Sinja
+
+  helpers do
+    prepend Sinja::Sequel::Core
+  end
+end
+```
+
+Note that you must use `prepend` (instead of including Sinja::Sequel::Core like
+a normal module of Sinatra helpers) in order to ensure that the included
+methods take precedence over Sinja's method stubs (e.g. `transaction`).
+[This][4] will hopefully be fixed in a future version of Sinatra.
+
+Prepending Core does the following to your application:
+
+* Configures `conflict_`, `not_found_`, and `validation_exceptions`, and
+  `validation_formatter`.
+* Defines a `database` helper that delegates to `Sequel::Model.db`.
+* Defines a `transaction` helper that delegates to `database.transaction`.
+* Defines a `validate!` helper that raises an error if `resource` is invalid
+  after a `create` or `update` action helper invocation.
+* Defines a simple equality-based `filter` helper that passes the filter params
+  to `Sequel::Dataset#where`.
+* Defines a `sort` helper that applies `Sequel.asc` and `Sequel.desc` to the
+  sort terms and passes them to `Sequel::Dataset#order`.
+* Defines a `finalize` helper that simply calls `Sequel::Dataset#all`.
+
+If the `:pagination` Sequel extension is loaded, it also does the following:
+
+* Configures `page_using` for page number- and size-based pagination, with an
+  additional record count parameter to avoid repetitive `SELECT COUNT` queries
+  while paging.
+* Defines a `page` helper that calls `Sequel::Dataset#paginate` and computes a
+  hash of page params that Sinja will use to construct the root pagination
+  links and add to the root metadata of the response.
+
+You may override any of the installed helpers by defining your own. Please see
+the [Sinja][1] documentation for more information about Sinja hooks and
+configurables, and the [Sequel][2] documentation for more information about
+Sequel plugins and features.
+
+### Helpers
+
+Include
+[Sinja::Sequel::Helpers](/extensions/sequel/lib/sinja/sequel/helpers.rb) after
+registering Sinja:
+
+```ruby
+require 'sinja'
+require 'sinja/sequel/helpers'
+
+class MyApp < Sinatra::Base
+  register Sinja
+
+  helpers Sinja::Sequel::Helpers
+end
+```
+
+This is the most common use-case. **Note that including Helpers will
+automatically prepend Core!**
+
+#### `next_pk`
+
+A convenience method to always return the primary key of the resource and the
+resource from your `create` action helpers. Simply use it instead of `next`!
+
+```ruby
+create do |attr|
+  next_pk Foo.create(attr)
+end
+```
+
+#### `add_missing`
+
+Take the key of a Sequel \*_to_many association and an array of resource
+identifier objects and add the "missing" records to the collection. Makes
+writing your `merge` action helpers a breeze!
+
+```ruby
+has_many :bars do
+  merge do |rios|
+    add_missing(:bars, rios)
+  end
+end
+```
+
+It will try to cast the ID of each resource identifier object by sending it the
+`:to_i` method; pass in a third argument to specify a different method (e.g. if
+the primary key of the `bars` table is a `varchar`, pass in `:to_s` instead).
+
+This helper also takes an optional block that can be used to filter
+subresources during processing. Simply return a truthy or falsey value from the
+block (or raise an error to abort the entire transaction):
+
+```ruby
+has_many :bars do
+  merge do |rios|
+    add_missing(:bars, rios) do |bar|
+      role?(:admin) || bar.owner == resource.owner
+    end
+  end
+end
+```
+
+#### `remove_present`
+
+Like `add_missing`, but removes the "present" records from the collection.
+Makes writing your `subtract` action helpers a breeze!
+
+#### `add_remove`
+
+Like `add_missing` and `remove_present`, but performs an efficient delta
+operation on the collection. Makes writing your `replace` action helpers a
+breeze!
+
+### Extension
+
+Register [Sinja::Sequel](/extensions/sequel/lib/sinja/sequel.rb) after
+registering Sinja:
+
+```ruby
+require 'sinja'
+require 'sinja/sequel'
+
+class MyApp < Sinatra::Base
+  register Sinja
+  register Sinja::Sequel
+end
+```
+
+**Note that registering the extension will automatically include Helpers!**
+
+After registering the extension, the `resource`, `has_many`, and `has_one` DSL
+keywords will generate basic action helpers. The default `create` action helper
+does not support client-generated IDs. These action helpers can be subsequently
+overridden, customized by setting action helper options (i.e. `:roles`) and/or
+defining `before_<action>` hooks, or removed entirely with `remove_<action>`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/mwpastore/sinja.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+
+[1]: https://github.com/mwpastore/sinja
+[2]: http://sequel.jeremyevans.net
+[3]: https://github.com/mwpastore/sinja/tree/master/demo-app
+[4]: https://github.com/sinatra/sinatra/issues/1213
+[5]: https://github.com/fotinakis/jsonapi-serializers
+[6]: https://github.com/fotinakis/jsonapi-serializers/pull/31#issuecomment-148193366

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList[File.expand_path('test/**/*_test.rb', __dir__)]
+  t.warning = false
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sinja-sequel'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sinatra/jsonapi/sequel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require 'sinja/sequel'
+require 'sinatra/jsonapi'
+
+module Sinatra
+  register JSONAPI::Sequel
+end

data/lib/sinja-sequel.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require 'sinja/sequel'

data/lib/sinja/sequel.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require 'sinja/sequel/helpers'
+require 'sinja/sequel/version'
+
+module Sinja
+  module Sequel
+    def self.registered(app)
+      app.helpers Helpers
+    end
+
+    def resource(res, try_convert=:to_i, &block)
+      klass = res.to_s.classify.constantize
+
+      super(res) do
+        register Resource
+
+        helpers do
+          def find(id)
+            klass[id.send(try_convert)]
+          end
+        end
+
+        show
+
+        show_many do |ids|
+          klass.where(klass.primary_key=>ids.map(&try_convert)).all
+        end
+
+        index do
+          klass.dataset
+        end
+
+        create do |attr|
+          tmp = klass.new
+          if respond_to?(:settable_fields)
+            tmp.set_fields(attr, settable_fields)
+          else
+            tmp.set(attr)
+          end
+          tmp.save(:validate=>false)
+          next_pk tmp
+        end
+
+        update do |attr|
+          if respond_to?(:settable_fields)
+            resource.update_fields(attr, settable_fields, :validate=>false, :missing=>:skip)
+          else
+            resource.set(attr)
+            resource.save_changes(:validate=>false)
+          end
+        end
+
+        destroy do
+          resource.destroy
+        end
+
+        instance_eval(&block) if block
+      end
+    end
+
+    module Resource
+      def has_one(rel, &block)
+        super(rel) do
+          pluck do
+            resource.send(rel)
+          end
+
+          prune(:sideload_on=>:update) do
+            resource.send("#{rel}=", nil)
+            resource.save_changes
+          end
+
+          graft(:sideload_on=>%i[create update]) do |rio|
+            klass = resource.class.association_reflection(rel).associated_class
+            resource.send("#{rel}=", klass.with_pk!(rio[:id]))
+            resource.save_changes(:validate=>!sideloaded?)
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+
+      def has_many(rel, &block)
+        super(rel) do
+          fetch do
+            resource.send("#{rel}_dataset")
+          end
+
+          clear(:sideload_on=>:update) do
+            resource.send("remove_all_#{rel}")
+          end
+
+          replace(:sideload_on=>:update) do |rios|
+            add_remove(rel, rios)
+          end
+
+          merge(:sideload_on=>:create) do |rios|
+            add_missing(rel, rios)
+          end
+
+          subtract do |rios|
+            remove_present(rel, rios)
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+    end
+  end
+end

data/lib/sinja/sequel/core.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'sequel'
+
+module Sinja
+  module Sequel
+    module Core
+      extend Forwardable
+
+      def self.prepended(base)
+        base.sinja do |c|
+          c.conflict_exceptions << ::Sequel::ConstraintViolation
+          c.not_found_exceptions << ::Sequel::NoMatchingRow
+          c.validation_exceptions << ::Sequel::ValidationFailed
+          c.validation_formatter = ->(e) { e.errors.keys.zip(e.errors.full_messages) }
+        end
+
+        base.include Pagination if ::Sequel::Database::EXTENSIONS.key?(:pagination)
+      end
+
+      def_delegator ::Sequel::Model, :db, :database
+
+      def_delegator :database, :transaction
+
+      define_method :filter, proc(&:where)
+
+      def sort(collection, fields)
+        collection.order(*fields.map { |k, v| ::Sequel.send(v, k) })
+      end
+
+      define_method :finalize, proc(&:all)
+
+      def validate!
+        raise ::Sequel::ValidationFailed, resource unless resource.valid?
+      end
+    end
+
+    module Pagination
+      def self.included(base)
+        base.sinja { |c| c.page_using = {
+          :number=>1,
+          :size=>10,
+          :record_count=>nil
+        }}
+      end
+
+      def page(collection, opts)
+        collection = collection.dataset unless collection.respond_to?(:paginate)
+
+        opts = settings._sinja.page_using.merge(opts)
+        collection = collection.paginate opts[:number].to_i, opts[:size].to_i,
+          (opts[:record_count].to_i if opts[:record_count])
+
+        # Attributes common to all pagination links
+        base = {
+          :size=>collection.page_size,
+          :record_count=>collection.pagination_record_count
+        }
+
+        pagination = {
+          :first=>base.merge(:number=>1),
+          :self=>base.merge(:number=>collection.current_page),
+          :last=>base.merge(:number=>collection.page_count)
+        }
+        pagination[:next] = base.merge(:number=>collection.next_page) if collection.next_page
+        pagination[:prev] = base.merge(:number=>collection.prev_page) if collection.prev_page
+
+        return collection, pagination
+      end
+    end
+  end
+end

data/lib/sinja/sequel/helpers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'sinja/sequel/core'
+
+module Sinja
+  module Sequel
+    module Helpers
+      def self.included(base)
+        base.prepend Core
+      end
+
+      def next_pk(resource, opts={})
+        [resource.pk, resource, opts]
+      end
+
+      def add_remove(association, rios, try_convert=:to_i)
+        meth_suffix = association.to_s.singularize
+        add_meth = "add_#{meth_suffix}".to_sym
+        remove_meth = "remove_#{meth_suffix}".to_sym
+
+        dataset = resource.send("#{association}_dataset")
+        klass = dataset.association_reflection.associated_class
+
+        # does not / will not work with composite primary keys
+        new_ids = rios.map { |rio| rio[:id].send(try_convert) }
+        transaction do
+          resource.lock!
+          old_ids = dataset.select_map(klass.primary_key)
+          in_common = old_ids & new_ids
+
+          (new_ids - in_common).each do |id|
+            subresource = klass.with_pk!(id)
+            resource.send(add_meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+
+          (old_ids - in_common).each do |id|
+            subresource = klass.with_pk!(id)
+            resource.send(remove_meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+
+          resource.reload
+        end
+      end
+
+      def add_missing(*args, &block)
+        add_or_remove(:add, :-, *args, &block)
+      end
+
+      def remove_present(*args, &block)
+        add_or_remove(:remove, :&, *args, &block)
+      end
+
+      private
+
+      def add_or_remove(meth_prefix, operator, association, rios, try_convert=:to_i)
+        meth = "#{meth_prefix}_#{association.to_s.singularize}".to_sym
+        transaction do
+          resource.lock!
+          venn(operator, association, rios, try_convert) do |subresource|
+            resource.send(meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+          resource.reload
+        end
+      end
+
+      def venn(operator, association, rios, try_convert)
+        dataset = resource.send("#{association}_dataset")
+        klass = dataset.association_reflection.associated_class
+        # does not / will not work with composite primary keys
+        rios.map { |rio| rio[:id].send(try_convert) }
+          .send(operator, dataset.select_map(klass.primary_key))
+          .each { |id| yield klass.with_pk!(id) }
+      end
+    end
+  end
+end

data/lib/sinja/sequel/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Sinja
+  module Sequel
+    VERSION = '0.1.0'
+  end
+end

data/sinja-sequel.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinja/sequel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sinja-sequel'
+  spec.version       = Sinja::Sequel::VERSION
+  spec.authors       = ['Mike Pastore']
+  spec.email         = ['mike@oobak.org']
+
+  spec.summary       = 'Sequel-specific Helpers and DSL for Sinja'
+  spec.homepage      = 'https://github.com/mwpastore/sinja/tree/master/extensions/sequel'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = %w[lib]
+
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_dependency 'sequel', '~> 4.0'
+  spec.add_dependency 'sinja', '>= 1.2.0.pre2', '< 2'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'minitest', '~> 5.9'
+  spec.add_development_dependency 'rake', '~> 12.0'
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: sinja-sequel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Pastore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sinja
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0.pre2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0.pre2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: 
+email:
+- mike@oobak.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sinatra/jsonapi/sequel.rb
+- lib/sinja-sequel.rb
+- lib/sinja/sequel.rb
+- lib/sinja/sequel/core.rb
+- lib/sinja/sequel/helpers.rb
+- lib/sinja/sequel/version.rb
+- sinja-sequel.gemspec
+homepage: https://github.com/mwpastore/sinja/tree/master/extensions/sequel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Sequel-specific Helpers and DSL for Sinja
+test_files: []