acts_as_holdable 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab95215af6bfe8d8811807c536ca35ca837a7c83d030c087986fd4d78fb37716
+  data.tar.gz: 548d98f061d57a4c7e12cf3a71cefa9808c0109e793c124d06747a52dfacd073
+SHA512:
+  metadata.gz: f43dd7e5ff2f853233b100bcc814615faad4ade99b49b5a4107e3a65c7caf1a73e2d99111ba786f7ea144098db761e92c7f345ba19a3655ae8a5fa6730bb0641
+  data.tar.gz: 54f10fd2c304f946f6bcab51aff8fced9c88842e44873e47611a9dbc44ad5de98b4d0479a1ddc094fa6565d7fb0cd06dbcfdf4092b4a5449a45535ebe50d6bed

data/README.md

@@ -0,0 +1,156 @@
+# ActsAsHoldable
+ActsAsHoldable allows resources to be held by users. It:
+
+* Is a MVC solution based on Rails engines
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'acts_as_holdable'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install acts_as_holdable
+```
+
+## Migrations
+
+```bash
+bundle exec rake acts_as_holdable_engine:install:migrations
+```
+
+## Holdables, Holders and Holdings
+
+To set-up a Holdable model, use acts_as_holdable. A Holdable model is enabled to be held.
+
+```ruby
+class Ticket < ApplicationRecord
+  acts_as_holdable
+end
+```
+
+To set-up a Holder model, use acts_as_holder. Only Holders can create holdings.
+
+```ruby
+class User < ApplicationRecord
+  acts_as_holder
+end
+```
+
+From this time on, a User can hold a Ticket with
+
+```ruby
+@user.hold! @ticket
+```
+
+A User can unhold a Ticket with
+
+```ruby
+@holding = @user.hold! @ticket
+@user.unhold! @holding
+```
+
+You can access holdings both from the Holdable and the Holder
+
+```ruby
+@ticket.holdings # return all holdings created on this ticket
+@user.holdings # return all holdings made by this user
+```
+
+## Configuring Options
+
+There are a number available options to make your models behave differently. They are all configurable in the Holdable model, passing a hash to `acts_as_holdable`
+
+Available options (with values) are:
+
+* `:on_hand_type`: Specifies how the `amount` of a holding (e.g. number of tickets from an event) affects the future availability of the holdable. Allowed values are:
+  * `:none`
+  * `:open`
+
+### No constraints
+
+The model accepts holdings without any constraint. This means every holder can create an infinite number of holdings on it and no capacity or time checks are performed.
+
+Creating a holding on this model means holding it forever and without care for other existing holdings. In other words, the number of holdings do not affect the availability of this holdable. (e.g. pre-ordering a product that will be released soon)
+
+### Capacity constraints
+
+The option `on_hand_type` may be used to set a constraint over the `amount` attribute of the holding
+
+#### No capacity constraints - `on_hand_type: :none`
+
+The model is holdable without capacity constraints.
+
+```ruby
+class Product < ActiveRecord::Base
+  # As `on_hand_type: :none` is a default and can be ommited
+  acts_as_holdable on_hand_type: :none
+end
+```
+
+#### Open capacity - `on_hand_type: :open`
+
+> WARNING - **migration needed!** - with this option the model must have an attribute `on_hand: :integer`
+
+The model is holdable until its `capacity` is reached. (e.g. an event't tickets types)
+
+**Configuration**
+
+```ruby
+class Event < ActiveRecord::Base
+  acts_as_holdable on_hand_type: :open
+end
+```
+
+**Creating a new holdable**
+
+Each instance of the model must define its capacity.
+
+```ruby
+@ticket = Ticket.new(...)
+@ticket.on_hand = 30 # This event allows 30 tickets
+@ticket.save!
+```
+
+**Holding**
+
+```ruby
+# Holding a model with `on_hand_type: :open` requires `:amount`
+
+@user1.hold! @ticket, amount: 5 # holding tickets for 5 people, OK
+@user2.hold! @ticket, amount: 20 # holding tickets for other 20 people, OK
+@user3.hold! @ticket, amount: 10 # overholding! raise ActsAsHoldable::AvailabilityError
+```
+
+## Holding resources on a span of time
+
+Holdings can be created to be 'living' within a span of time, if the holding doesn't gets confirmed within the time span, it will be destroyed. 
+
+
+```ruby
+@holding = @user.hold_for(@ticket, duration: 10.minutes, amount: 1)
+```
+
+A User can confirm a holding with
+
+```ruby
+@user.confirm_holding!(@holding)
+```
+
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+### Acknowledgements
+
+To speed-up the initialization process of this project, the structure of this repository was strongly influenced by ActsAsBookable by Tandù srl.

data/Rakefile

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsHoldable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  acts_as_holdable:
+    errors:
+      messages:
+        holding:
+          must_be_holdable: "cannot hold a %{model} as it\'s not holdable"
+          must_be_holder: "a %{model} cannot hold a resource, because %{model} is not a holder"
+        availability:
+          amount_gt_on_hand: "amount cannot be greater than %{model} on_hand"
+          already_held: "the %{model} is full"

data/config/locales/es.yml

@@ -0,0 +1,10 @@
+es-MX:
+  acts_as_holdable:
+    errors:
+      messages:
+        holding:
+          must_be_holdable: "No se puede apartar %{model} ya que no es apartable"
+          must_be_holder: "%{model} no puede apartar un recurso, porque %{model} no es un agente de apartados"
+        availability:
+          amount_gt_on_hand: "cantidad no puede ser mayor que la capacidad de %{model}"
+          already_held: "%{model} está totalmente apartado"

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/db/migrate/20180530211641_acts_as_holdable_holdings.rb

@@ -0,0 +1,12 @@
+class ActsAsHoldableHoldings < ActiveRecord::Migration[5.2]
+  def change
+    create_table :acts_as_holdable_holdings, force: true do |t|
+      t.references :holdable, polymorphic: true, index: { name: "index_acts_as_holdable_holdings_holdable" }
+      t.references :holder, polymorphic: true, index: { name: "index_acts_as_holdable_holdings_holder" }
+      t.column :amount, :integer
+      t.column :job_pid, :string
+
+      t.timestamps
+    end
+  end
+end

data/lib/acts_as_holdable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'acts_as_holdable/engine'
+require 'active_job'
+require 'sidekiq-status'
+
+module ActsAsHoldable
+  extend ActiveSupport::Autoload
+
+  autoload :T
+  autoload :Holdable
+  autoload :Holder
+  autoload :Holding
+  autoload :DbUtils
+
+  autoload_under 'holdable' do
+    autoload :Core
+  end
+
+  class InitializationError < StandardError
+    def initialize(model, message)
+      super "Error initializing acts_as_holdable on #{model} - " + message
+    end
+  end
+
+  class OptionsInvalid < StandardError
+    def initialize(model, message)
+      super "Error validating options for #{model} - " + message
+    end
+  end
+
+  class AvailabilityError < StandardError
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsHoldable::Holdable
+  include ActsAsHoldable::Holder
+end

data/lib/acts_as_holdable/db_utils.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  module DBUtils
+    class << self
+      def connection
+        ActsAsHoldable::Holding.connection
+      end
+
+      def using_postgresql?
+        connection && connection.adapter_name == 'PostgreSQL'
+      end
+
+      def using_mysql?
+        connection && connection.adapter_name == 'Mysql2'
+      end
+
+      def using_sqlite?
+        connection && connection.adapter_name == 'SQLite'
+      end
+
+      def like_operator
+        using_postgresql? ? 'ILIKE' : 'LIKE'
+      end
+
+      # escape _ and % characters in strings, since these are wildcards in SQL.
+      def escape_like(str)
+        str.gsub(/[!%_]/) { |x| '!' + x }
+      end
+    end
+  end
+end

data/lib/acts_as_holdable/engine.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/acts_as_holdable/holdable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  module Holdable
+    def holdable?
+      false
+    end
+
+    def acts_as_holdable(options = {})
+      holdable(options)
+    end
+
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def holdable(options)
+      if holdable?
+        self.holding_opts = options
+      else
+        class_attribute :holding_opts
+        self.holding_opts = options
+
+        class_eval do
+          has_many :holdings, as: :holdable, dependent: :destroy, class_name: '::ActsAsHoldable::Holding'
+
+          validates :on_hand, presence: true, if: :on_hand_required?,
+                              numericality: { only_integer: true,
+                                              greater_than_or_equal_to: 0 }
+
+          def self.holdable?
+            true
+          end
+
+          def on_hand_required?
+            holding_opts && holding_opts[:on_hand_type] != :none
+          end
+        end
+      end
+
+      include Core
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/acts_as_holdable/holdable/core.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  module Holdable
+    module Core
+      def self.included(base)
+        base.extend ActsAsHoldable::Holdable::Core::ClassMethods
+        base.include ActsAsHoldable::Holdable::Core::InstanceMethods
+
+        base.initialize_acts_as_holdable_core
+      end
+
+      module ClassMethods
+        def initialize_acts_as_holdable_core
+          set_options
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def validate_holding_options!(options)
+          unpermitted_params = []
+          required_params = {}
+
+          case holding_opts[:on_hand_type]
+          when :closed
+            required_params[:amount] = [Integer]
+          when :open
+            required_params[:amount] = [Integer]
+          when :none
+            unpermitted_params << :amount
+          end
+
+          # Actual validation
+          unpermitted_params = unpermitted_params.select { |p| options.key?(p) }
+                                                 .map { |p| "'#{p}'" }
+
+          wrong_types = required_params
+                        .select { |k, v| options.key?(k) && v.select { |type| options[k].is_a?(type) }.length.zero? }
+                        .map { |k, v| "'#{k}' must be a '#{v.join(' or ')}' but '#{options[k].class}' found" }
+
+          required_params = required_params.reject { |k, _v| options.key?(k) }
+                                           .map { |k, _v| "'#{k}'" }
+
+          # Raise OptionsInvalid if some invalid parameters were found
+          if (unpermitted_params.length + required_params.length + wrong_types.length).positive?
+            message = ''
+            message << " unpermitted parameters: #{unpermitted_params.join(',')}." unless unpermitted_params.empty?
+            message << " missing parameters: #{required_params.join(',')}." unless required_params.empty?
+            message << " parameters type mismatch: #{wrong_types.join(',')}" unless wrong_types.empty?
+            raise ActsAsHoldable::OptionsInvalid.new(self, message)
+          end
+          true
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def set_options
+          holding_opts[:preset] = :ticket
+
+          # Validates options
+          permitted_options = {
+            on_hand_type: %i[open closed none],
+            preset: [:ticket]
+          }
+
+          holding_opts.each_pair do |key, val|
+            # rubocop:disable Style/GuardClause
+            if !permitted_options.key? key
+              raise ActsAsHoldable::InitializationError.new(self, "#{key} is not a valid option")
+            elsif !permitted_options[key].include? val
+              raise ActsAsHoldable::InitializationError.new(self, "#{val} is not a valid value for #{key}. Allowed values: #{permitted_options[key]}")
+            end
+            # rubocop:enable Style/GuardClause
+          end
+
+          defaults = case holding_opts[:preset]
+                     when :ticket
+                       {
+                         on_hand_type: :open
+                       }
+                     else
+                       {
+                         on_hand_type: :none
+                       }
+                     end
+
+          # Merge options with defaults
+          holding_opts.reverse_merge!(defaults)
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      module InstanceMethods
+        def check_availability!(opts)
+          # validates options
+          validate_holding_options!(opts)
+
+          if holding_opts[:on_hand_type] != :none
+            # Amount > on_hand
+            if opts[:amount] > on_hand
+              raise ActsAsHoldable::AvailabilityError,
+                    ActsAsHoldable::T.er('.availability.amount_gt_on_hand', model: self.class.to_s)
+            end
+          end
+          true
+        end
+
+        def check_availability(opts)
+          check_availability!(opts)
+        rescue ActsAsHoldable::AvailabilityError
+          false
+        end
+
+        def hold!(holder, opts)
+          holder.hold(self, opts)
+        end
+
+        def validate_holding_options!(opts)
+          self.class.validate_holding_options!(opts)
+        end
+
+        def holder?
+          self.class.holder?
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_holdable/holder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'jobs/unhold_job'
+module ActsAsHoldable
+  module Holder
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_holder(_opts = {})
+        class_eval do
+          has_many :holdings, as: :holder, dependent: :destroy, class_name: '::ActsAsHoldable::Holding'
+        end
+
+        include ActsAsHoldable::Holder::InstanceMethods
+        extend ActsAsHoldable::Holder::SingletonMethods
+      end
+
+      def holder?
+        false
+      end
+    end
+
+    module InstanceMethods
+      def hold!(holdable, opts = {})
+        # validates availability
+        holdable.check_availability!(opts) if holdable.class.holdable?
+
+        holding_params = opts.merge(holder: self, holdable: holdable)
+        holding = ActsAsHoldable::Holding.create!(holding_params)
+
+        holdable.reload
+        holding
+      end
+
+      def unhold!(holding)
+        # deletes current holding
+        ActsAsHoldable::Holding.destroy(holding.id)
+        reload
+        true
+      end
+
+      def hold_for(holdable, opts = {})
+        # Clean params for Bookings
+        holding_opts = opts.except(:duration)
+
+        # Creates the Booking
+        holding = hold!(holdable, holding_opts)
+
+        # Sets a Job to delete the Booking
+        job = UnholdJob.set(wait: opts[:duration]).perform_later(holding.id)
+        holding.update(job_pid: job.provider_job_id)
+        holding
+      end
+
+      def confirm_holding!(holding)
+        return false unless holding.job_pid
+        Sidekiq::Status.unschedule(holding.job_pid)
+        holding.update(job_pid: nil)
+        holding
+      end
+
+      def holder?
+        self.class.holder?
+      end
+    end
+
+    module SingletonMethods
+      def holder?
+        true
+      end
+    end
+  end
+end

data/lib/acts_as_holdable/holding.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  # Holding model. Store in host database holdings made by holders on holdables
+  class Holding < ::ActiveRecord::Base
+    self.table_name = 'acts_as_holdable_holdings'
+
+    belongs_to :holdable, polymorphic: true
+    belongs_to :holder, polymorphic: true
+
+    validates_presence_of :holdable
+    validates_presence_of :holder
+
+    validate :holdable_is_holdable,
+             :holder_is_holder
+
+    validates :amount, presence: true, numericality: { only_integer: true,
+                                                       greater_than_or_equal_to: 0 }
+
+    private
+
+    # Validation method. Check if the holded model is actually holdable
+    def holdable_is_holdable
+      return unless holdable.present? && !holdable.class.holdable?
+      errors.add(:holdable, T.er('holding.must_be_holdable',
+                                 model: holdable.class.to_s))
+    end
+
+    # Validation method. Check if the holder model is actually a holder
+    def holder_is_holder
+      return unless holder.present? && !holder.class.holder?
+      errors.add(:holder, T.er('holder.must_be_holder',
+                               model: holder.class.to_s))
+    end
+  end
+end

data/lib/acts_as_holdable/t.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  module T
+    def self.t(message, opts = {})
+      I18n.t('.acts_as_holdable.' + message, opts)
+    end
+
+    def self.er(message, opts = {})
+      t('errors.messages.' + message, opts)
+    end
+  end
+end

data/lib/acts_as_holdable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActsAsHoldable
+  VERSION = '0.1.1'
+end

data/lib/jobs/unhold_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class UnholdJob < ActiveJob::Base
+  discard_on ActiveRecord::RecordNotFound
+  queue_as :default
+
+  def perform(holding_id)
+    ActsAsHoldable::Holding.destroy(holding_id) if booking_exists?(holding_id)
+  end
+
+  private
+
+  def booking_exists?(holding_id)
+    ActsAsHoldable::Holding.find_by(id: holding_id)
+  end
+end

data/lib/tasks/acts_as_booked_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :acts_as_holdable do
+#   # Task goes here
+# end

data/lib/tasks/acts_as_holdable_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :acts_as_holdable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_holdable
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Nora Gabriela Alvarado
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq-status
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bump
+  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: combustion
+  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: coveralls
+  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: rspec
+  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: rubocop
+  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: simplecov
+  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: Description of ActsAsHoldable.
+email:
+- noragmora@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/acts_as_booked_manifest.js
+- config/locales/en.yml
+- config/locales/es.yml
+- config/routes.rb
+- db/migrate/20180530211641_acts_as_holdable_holdings.rb
+- lib/acts_as_holdable.rb
+- lib/acts_as_holdable/db_utils.rb
+- lib/acts_as_holdable/engine.rb
+- lib/acts_as_holdable/holdable.rb
+- lib/acts_as_holdable/holdable/core.rb
+- lib/acts_as_holdable/holder.rb
+- lib/acts_as_holdable/holding.rb
+- lib/acts_as_holdable/t.rb
+- lib/acts_as_holdable/version.rb
+- lib/jobs/unhold_job.rb
+- lib/tasks/acts_as_booked_tasks.rake
+- lib/tasks/acts_as_holdable_tasks.rake
+homepage: https://gitlab.com/aromaron/acts_as_holdable
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Summary of ActsAsHoldable.
+test_files: []