sequel-through 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f97ae5f870b6431b6a0d8186421ad8422ce24b58de83205b377e0c854d832578
+  data.tar.gz: 7eba0d88aa13b1908dbc2a39e48b2c2b43879a623ca51d7f933519a008bf12e4
+SHA512:
+  metadata.gz: 52aa46a33e6162b18d0df2b5e3d401010fc32ac0984d776bb25db4ce3d7dc5672b94ec8a789c91dafa199018160e7a6a76a6804557a7b886fc88614b412f159f
+  data.tar.gz: cd274aa38361bda1aba76e5e779d647262efbeaefcfb9015b8fde65c6b27d846348ae9bd64647a27e09687657a2b1127e138db0c5149ada8744ce17fc4865241

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+/gemfiles/*.lock
+*.gem

data/.travis.yml

@@ -0,0 +1,9 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6
+  - 2.5
+  - 2.4
+before_install: gem install bundler

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/kenaniah/sequel-through" }
+
+# Specify your gem's dependencies in sequel-through.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Kenaniah Cerny
+
+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,41 @@
+# Sequel::Through
+
+[![Gem Version](https://badge.fury.io/rb/sequel-through.svg)](https://badge.fury.io/rb/sequel-through)
+[![Build Status](https://secure.travis-ci.org/kenaniah/sequel-through.svg)](https://travis-ci.org/kenaniah/sequel-through)
+[![Inline docs](https://inch-ci.org/github/kenaniah/sequel-through.svg?branch=master)](https://inch-ci.org/github/kenaniah/sequel-through)
+
+This gem extends [sequel](https://github.com/jeremyevans/sequel)'s associations to provide the ability to create associations that flow through other associations, similar to how `:through` works in [ActiveRecord](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sequel-through'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sequel-through
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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/kenaniah/sequel-through.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sequel/through"
+
+# 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(__FILE__)

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/sequel/plugins/cyclical_association_solver.rb

@@ -0,0 +1,65 @@
+module Sequel
+  module Plugins
+    module CyclicalAssociationSolver
+
+      # Ensure through associations are loaded
+      def self.apply mod
+        mod.plugin(:through_associations)
+      end
+
+      module ClassMethods
+
+        @@_resolving = false
+        @@_resolver_stack = []
+
+        # Solves any remaining cyclical associations
+        def solve_cyclical_associations!
+
+          # Keep trying to solve as long as the stack length is reduced each time
+          length = nil
+          while length != @@_resolver_stack.count do
+
+            length = @@_resolver_stack.count
+            stack = @@_resolver_stack
+
+            # Attempt to solve remaining cyclical associations
+            @@_resolver_stack = []
+            stack.each do |klass, assoc_type, name, opts, block|
+              klass.send(assoc_type, name, **opts, &block)
+            end
+
+          end
+
+          # Output errors for any unsolved associations
+          @@_resolving = true
+          @@_resolver_stack.each do |klass, assoc_type, name, opts, block|
+            klass.send(assoc_type, name, **opts, &block)
+          end
+          @@_resolving = false
+
+        end
+
+        def associate_through(type, name, opts, &block)
+          begin
+            result = super
+          rescue \
+            Sequel::Plugins::ThroughAssociations::MissingAssociation, \
+            Sequel::Plugins::ThroughAssociations::NoAssociationPath \
+          => e
+
+            # Re-raise if we were resolving
+            raise e if @@_resolving
+
+            # Otherwise, attempt to resolve later
+            unless result
+              @@_resolver_stack.push([self, type, name, opts, block])
+              return
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sequel/plugins/through_associations.rb

@@ -0,0 +1,198 @@
+module Sequel
+  module Plugins
+    module ThroughAssociations
+
+      ASSOCIATION_THROUGH_TYPES = {
+        :one_to_many => :one_through_many,
+        :many_to_one => :one_through_many,
+        :many_to_many => :many_through_many
+        # one_to_one
+        # many_to_pg_array
+        # pg_array_to_many
+      }
+
+      class MissingAssociation < Sequel::Error; end
+      class NoAssociationPath < Sequel::Error; end
+
+      # Ensure associations are loaded
+      def self.apply mod
+        mod.plugin :many_through_many
+      end
+
+      module ClassMethods
+
+        def associate type, name, opts = OPTS, &block
+
+          # Handle associations that are based on others
+          if opts[:through] && !type.to_s.include?("_through_")
+            return associate_through type, name, opts, &block
+          end
+
+          super
+
+        end
+
+        # Associates a related model with the current model using another association
+        # as the intermediary.
+        def associate_through type, name, opts, &block
+          raise Error, "#{type} does not support through associations" unless assoc_type = Sequel.synchronize{ASSOCIATION_THROUGH_TYPES[type]}
+
+          result = find_association_path **opts, name: name, models: self, from_through: true
+
+          # Remove the last table if it matches the destination table
+          dest_model = result[:models].pop
+          result[:tables].pop if result[:tables].last == dest_model.table_name
+
+          # Build the association path
+          path = []
+          left_key = result[:keys].shift
+          result[:tables].each do |table|
+            path.push [table, result[:keys].shift, result[:keys].shift]
+          end
+
+          # Create the association
+          if assoc_type.to_s.ends_with? "_through_many"
+            # *_through_many has a path argument
+            self.send(assoc_type,
+              name,
+              path,
+              left_primary_key: left_key,
+              right_primary_key: result[:keys].shift,
+              class: dest_model,
+              **opts,
+              originally_through: opts[:through],
+              &block
+            )
+          else
+            # *_through_one does not have a path argument
+            self.send(assoc_type,
+              name,
+              left_primary_key: left_key,
+              right_primary_key: result[:keys].shift,
+              class: dest_model,
+              **opts,
+              originally_through: opts[:through],
+              &block
+            )
+          end
+        end
+
+        # Recurses through associations until a path to the destination is completed
+        def find_association_path opts
+
+          # Initialize arguments
+          [:tables, :keys, :through, :models, :assocs].each do |k|
+            opts[k] ||= []
+            opts[k] = [opts[k]] unless Array === opts[k]
+            opts[k] = opts[k].dup
+          end
+
+          # Find the linked association
+          assoc = \
+            opts[:models].last.association_reflection(opts[:through].last.to_s.pluralize.to_sym) \
+            || opts[:models].last.association_reflection(opts[:through].last.to_s.singularize.to_sym)
+
+          # Short circuit if association does not exist
+          unless assoc
+
+            # Determine if finished or if the last relation is missing
+            if opts[:from_through]
+
+              m = opts[:models].pop
+              t = opts[:through].pop
+              path = [m]
+
+              opts[:models].zip(opts[:through]).each do |model, through|
+                path.push "#{model}.#{through}"
+              end
+
+              raise MissingAssociation, "#{m} is missing through association :#{t} from #{path.join " -> "}"
+
+            else
+
+              if opts[:assocs].last[:name].to_s.singularize != (opts[:using] || opts[:name]).to_s.singularize
+                text = "#{opts[:models].first}.#{opts[:name]} could not be resolved through path #{opts[:models].zip(opts[:through]).map{|model, through| "#{model}.#{through}"}.join " -> "}"
+                raise MissingAssociation, text
+              end
+
+              return opts
+
+            end
+
+          end
+
+          # Store the association
+          opts[:assocs].push assoc
+
+          # Handle *_through_many associations
+          if assoc[:type].to_s.ends_with? "_through_many"
+
+            opts[:through].push assoc[:originally_through]
+            opts[:from_through] = true
+
+            # Search through the existing model first, falling back to the associated model
+            search = [
+              opts[:models].last,
+              assoc[:class] || assoc[:class_name].constantize
+            ]
+            return begin
+              model = search.shift
+              raise NoAssociationPath, opts unless model
+              self.find_association_path **opts, models: opts[:models] + [model]
+            rescue MissingAssociation
+              # Try the next model in the search path
+              retry
+            end
+
+          end
+
+          # Move to the new model
+          opts[:models].push assoc[:class] || assoc[:class_name].constantize
+
+          # Read the through association if present
+          if assoc[:through]
+            opts[:through].push assoc[:using] || assoc[:through]
+            opts[:from_through] = true
+            opts[:using] = nil
+            return self.find_association_path **opts
+          end
+
+          # Otherwise, add the new table to the stack
+          if opts[:from_through] && opts[:models].last.respond_to?(:cti_tables)
+            opts[:tables].push opts[:models].last.cti_tables.first
+          else
+            opts[:tables].push opts[:models].last.table_name
+          end
+
+          # Left side
+          case assoc[:type]
+            when :one_to_many, :one_to_one # 1:_
+              opts[:keys].push assoc.primary_key
+            when :many_to_one # n:_
+              opts[:keys].push assoc[:key]
+            else
+              raise
+          end
+
+          # Right side
+          case assoc[:type]
+            when :many_to_one, :one_to_one # _:1
+              opts[:keys].push assoc.primary_key
+            when :one_to_many # _:n
+              opts[:keys].push assoc[:key]
+            else
+              raise
+          end
+
+          # Check for a source association
+          opts[:through].push opts[:using] || opts[:name]
+          opts[:from_through] = false
+          return self.find_association_path **opts
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sequel/through.rb

@@ -0,0 +1,3 @@
+require "sequel"
+require "sequel/plugins/through_associations"
+require "sequel/plugins/cyclical_association_solver"

data/sequel-through.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "sequel-through"
+  spec.version       = "0.3.0"
+  spec.authors       = ["Kenaniah Cerny"]
+  spec.email         = ["kenaniah@gmail.com"]
+
+  spec.summary       = "Adds support for :through associations to sequel"
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/kenaniah/sequel-through"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.4"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/kenaniah/sequel-through"
+    spec.metadata["changelog_uri"] = "https://github.com/kenaniah/sequel-through/blob/master/CHANGELOG.md"
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency  "sequel", "~> 5"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: sequel-through
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Kenaniah Cerny
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: minitest
+  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: Adds support for :through associations to sequel
+email:
+- kenaniah@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sequel/plugins/cyclical_association_solver.rb
+- lib/sequel/plugins/through_associations.rb
+- lib/sequel/through.rb
+- sequel-through.gemspec
+homepage: https://github.com/kenaniah/sequel-through
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kenaniah/sequel-through
+  source_code_uri: https://github.com/kenaniah/sequel-through
+  changelog_uri: https://github.com/kenaniah/sequel-through/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Adds support for :through associations to sequel
+test_files: []