draper 4.0.4 → 4.0.5

data/bin/bundle

@@ -1,114 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'bundle' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "rubygems"
-
-m = Module.new do
-  module_function
-
-  def invoked_as_script?
-    File.expand_path($0) == File.expand_path(__FILE__)
-  end
-
-  def env_var_version
-    ENV["BUNDLER_VERSION"]
-  end
-
-  def cli_arg_version
-    return unless invoked_as_script? # don't want to hijack other binstubs
-    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
-    bundler_version = nil
-    update_index = nil
-    ARGV.each_with_index do |a, i|
-      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
-        bundler_version = a
-      end
-      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
-      bundler_version = $1
-      update_index = i
-    end
-    bundler_version
-  end
-
-  def gemfile
-    gemfile = ENV["BUNDLE_GEMFILE"]
-    return gemfile if gemfile && !gemfile.empty?
-
-    File.expand_path("../../Gemfile", __FILE__)
-  end
-
-  def lockfile
-    lockfile =
-      case File.basename(gemfile)
-      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
-      else "#{gemfile}.lock"
-      end
-    File.expand_path(lockfile)
-  end
-
-  def lockfile_version
-    return unless File.file?(lockfile)
-    lockfile_contents = File.read(lockfile)
-    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
-    Regexp.last_match(1)
-  end
-
-  def bundler_version
-    @bundler_version ||=
-      env_var_version || cli_arg_version ||
-        lockfile_version
-  end
-
-  def bundler_requirement
-    return "#{Gem::Requirement.default}.a" unless bundler_version
-
-    bundler_gem_version = Gem::Version.new(bundler_version)
-
-    requirement = bundler_gem_version.approximate_recommendation
-
-    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
-
-    requirement += ".a" if bundler_gem_version.prerelease?
-
-    requirement
-  end
-
-  def load_bundler!
-    ENV["BUNDLE_GEMFILE"] ||= gemfile
-
-    activate_bundler
-  end
-
-  def activate_bundler
-    gem_error = activation_error_handling do
-      gem "bundler", bundler_requirement
-    end
-    return if gem_error.nil?
-    require_error = activation_error_handling do
-      require "bundler/version"
-    end
-    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
-    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
-    exit 42
-  end
-
-  def activation_error_handling
-    yield
-    nil
-  rescue StandardError, LoadError => e
-    e
-  end
-end
-
-m.load_bundler!
-
-if m.invoked_as_script?
-  load Gem.bin_path("bundler", "bundle")
-end

data/bin/rake

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rake' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-bundle_binstub = File.expand_path("../bundle", __FILE__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rake", "rake")

data/draper.gemspec

@@ -1,34 +0,0 @@
-require_relative 'lib/draper/version'
-
-Gem::Specification.new do |s|
-  s.name        = "draper"
-  s.version     = Draper::VERSION
-  s.authors     = ["Jeff Casimir", "Steve Klabnik"]
-  s.email       = ["jeff@casimircreative.com", "steve@steveklabnik.com"]
-  s.homepage    = "https://github.com/drapergem/draper"
-  s.summary     = "View Models for Rails"
-  s.description = "Draper adds an object-oriented layer of presentation logic to your Rails apps."
-  s.license     = "MIT"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = '>= 2.2.2'
-
-  s.add_dependency 'activesupport', '>= 5.0'
-  s.add_dependency 'actionpack', '>= 5.0'
-  s.add_dependency 'request_store', '>= 1.0'
-  s.add_dependency 'activemodel', '>= 5.0'
-  s.add_dependency 'activemodel-serializers-xml', '>= 1.0'
-  s.add_dependency 'ruby2_keywords'
-
-  s.add_development_dependency 'ammeter'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec-rails'
-  s.add_development_dependency 'rspec-activerecord-expectations'
-  s.add_development_dependency 'minitest-rails'
-  s.add_development_dependency 'capybara'
-  s.add_development_dependency 'rubocop'
-  s.add_development_dependency 'simplecov'
-end

data/spec/draper/collection_decorator_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/view_helpers'
-
-module Draper
-  describe CollectionDecorator do
-    it_behaves_like "view helpers", CollectionDecorator.new([])
-
-    describe "#initialize" do
-      describe "options validation" do
-        it "does not raise error on valid options" do
-          valid_options = {with: Decorator, context: {}}
-          expect{CollectionDecorator.new([], valid_options)}.not_to raise_error
-        end
-
-        it "raises error on invalid options" do
-          expect{CollectionDecorator.new([], foo: "bar")}.to raise_error ArgumentError, /Unknown key/
-        end
-      end
-    end
-
-    context "with context" do
-      it "stores the context itself" do
-        context = {some: "context"}
-        decorator = CollectionDecorator.new([], context: context)
-
-        expect(decorator.context).to be context
-      end
-
-      it "passes context to the individual decorators" do
-        context = {some: "context"}
-        decorator = CollectionDecorator.new([Product.new, Product.new], context: context)
-
-        decorator.each do |item|
-          expect(item.context).to be context
-        end
-      end
-    end
-
-    describe "#context=" do
-      it "updates the stored context" do
-        decorator = CollectionDecorator.new([], context: {some: "context"})
-        new_context = {other: "context"}
-
-        decorator.context = new_context
-        expect(decorator.context).to be new_context
-      end
-
-      context "when the collection is already decorated" do
-        it "updates the items' context" do
-          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
-          decorator.decorated_collection # trigger decoration
-          new_context = {other: "context"}
-
-          decorator.context = new_context
-          decorator.each do |item|
-            expect(item.context).to be new_context
-          end
-        end
-      end
-
-      context "when the collection has not yet been decorated" do
-        it "does not trigger decoration" do
-          decorated = CollectionDecorator.new([]).tap(&:to_a)
-          undecorated = CollectionDecorator.new([])
-
-          expect(decorated.instance_variable_defined?(:@decorated_collection)).to be_truthy
-          expect(undecorated.instance_variable_defined?(:@decorated_collection)).to be_falsy
-        end
-
-        it "sets context after decoration is triggered" do
-          decorator = CollectionDecorator.new([Product.new, Product.new], context: {some: "context"})
-          new_context = {other: "context"}
-
-          decorator.context = new_context
-          decorator.each do |item|
-            expect(item.context).to be new_context
-          end
-        end
-      end
-    end
-
-    describe "item decoration" do
-      it "sets decorated items' source models" do
-        collection = [Product.new, Product.new]
-        decorator = CollectionDecorator.new(collection)
-
-        decorator.zip collection do |item, object|
-          expect(item.object).to be object
-        end
-      end
-
-      context "when the :with option was given" do
-        it "uses the :with option" do
-          decorator = CollectionDecorator.new([Product.new], with: OtherDecorator).first
-
-          expect(decorator).to be_decorated_with OtherDecorator
-        end
-      end
-
-      context "when the :with option was not given" do
-        it "infers the item decorator from each item" do
-          decorator = CollectionDecorator.new([double(decorate: :inferred_decorator)]).first
-
-          expect(decorator).to be :inferred_decorator
-        end
-      end
-    end
-
-    describe ".delegate" do
-      protect_class ProductsDecorator
-
-      it "defaults the :to option to :object" do
-        expect(Object).to receive(:delegate).with(:foo, :bar, to: :object)
-        ProductsDecorator.delegate :foo, :bar
-      end
-
-      it "does not overwrite the :to option if supplied" do
-        expect(Object).to receive(:delegate).with(:foo, :bar, to: :baz)
-        ProductsDecorator.delegate :foo, :bar, to: :baz
-      end
-    end
-
-    describe "#find" do
-      it "decorates Enumerable#find" do
-        decorator = CollectionDecorator.new([])
-
-        expect(decorator.decorated_collection).to receive(:find).and_return(:delegated)
-        expect(decorator.find{|p| p.title == "title"}).to be :delegated
-      end
-    end
-
-    describe "#to_ary" do
-      # required for `render @collection` in Rails
-      it "delegates to the decorated collection" do
-        decorator = CollectionDecorator.new([])
-
-        expect(decorator.decorated_collection).to receive(:to_ary).and_return(:delegated)
-        expect(decorator.to_ary).to be :delegated
-      end
-    end
-
-    it "delegates array methods to the decorated collection" do
-      decorator = CollectionDecorator.new([])
-
-      allow(decorator).to receive_message_chain(:decorated_collection, :[]).with(42).and_return(:delegated)
-      expect(decorator[42]).to be :delegated
-    end
-
-    describe "#==" do
-      context "when comparing to a collection decorator with the same object" do
-        it "returns true" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = ProductsDecorator.new(object)
-
-          expect(decorator == other).to be_truthy
-        end
-      end
-
-      context "when comparing to a collection decorator with a different object" do
-        it "returns false" do
-          decorator = CollectionDecorator.new([Product.new, Product.new])
-          other = ProductsDecorator.new([Product.new, Product.new])
-
-          expect(decorator == other).to be_falsey
-        end
-      end
-
-      context "when comparing to a collection of the same items" do
-        it "returns true" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = object.dup
-
-          expect(decorator == other).to be_truthy
-        end
-      end
-
-      context "when comparing to a collection of different items" do
-        it "returns false" do
-          decorator = CollectionDecorator.new([Product.new, Product.new])
-          other = [Product.new, Product.new]
-
-          expect(decorator == other).to be_falsey
-        end
-      end
-
-      context "when the decorated collection has been modified" do
-        it "is no longer equal to the object" do
-          object = [Product.new, Product.new]
-          decorator = CollectionDecorator.new(object)
-          other = object.dup
-
-          decorator << Product.new.decorate
-          expect(decorator == other).to be_falsey
-        end
-      end
-    end
-
-    describe "#to_s" do
-      context "when :with option was given" do
-        it "returns a string representation of the collection decorator" do
-          decorator = CollectionDecorator.new(["a", "b", "c"], with: ProductDecorator)
-
-          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of ProductDecorator for ["a", "b", "c"]>'
-        end
-      end
-
-      context "when :with option was not given" do
-        it "returns a string representation of the collection decorator" do
-          decorator = CollectionDecorator.new(["a", "b", "c"])
-
-          expect(decorator.to_s).to eq '#<Draper::CollectionDecorator of inferred decorators for ["a", "b", "c"]>'
-        end
-      end
-
-      context "for a custom subclass" do
-        it "uses the custom class name" do
-          decorator = ProductsDecorator.new([])
-
-          expect(decorator.to_s).to match(/ProductsDecorator/)
-        end
-      end
-    end
-
-    describe '#object' do
-      it 'returns the underlying collection' do
-        collection = [Product.new]
-        decorator = ProductsDecorator.new(collection)
-
-        expect(decorator.object).to eq collection
-      end
-    end
-
-    describe '#decorated?' do
-      it 'returns true' do
-        decorator = ProductsDecorator.new([Product.new])
-
-        expect(decorator).to be_decorated
-      end
-    end
-
-    describe '#decorated_with?' do
-      it "checks if a decorator has been applied to a collection" do
-        decorator = ProductsDecorator.new([Product.new])
-
-        expect(decorator).to be_decorated_with ProductsDecorator
-        expect(decorator).not_to be_decorated_with OtherDecorator
-      end
-    end
-
-    describe '#kind_of?' do
-      it 'asks the kind of its decorated collection' do
-        decorator = ProductsDecorator.new([])
-        expect(decorator.decorated_collection).to receive(:kind_of?).with(Array).and_return("true")
-        expect(decorator.kind_of?(Array)).to eq "true"
-      end
-
-      context 'when asking the underlying collection returns false' do
-        it 'asks the CollectionDecorator instance itself' do
-          decorator = ProductsDecorator.new([])
-          allow(decorator.decorated_collection).to receive(:kind_of?).with(::Draper::CollectionDecorator).and_return(false)
-          expect(decorator.kind_of?(::Draper::CollectionDecorator)).to be true
-        end
-      end
-    end
-
-    describe '#is_a?' do
-      it 'aliases to #kind_of?' do
-        decorator = ProductsDecorator.new([])
-        expect(decorator.method(:kind_of?)).to eq decorator.method(:is_a?)
-      end
-    end
-
-    describe "#replace" do
-      it "replaces the decorated collection" do
-        decorator = CollectionDecorator.new([Product.new])
-        replacement = [:foo, :bar]
-
-        decorator.replace replacement
-        expect(decorator).to match_array replacement
-      end
-
-      it "returns itself" do
-        decorator = CollectionDecorator.new([Product.new])
-
-        expect(decorator.replace([:foo, :bar])).to be decorator
-      end
-    end
-  end
-end

data/spec/draper/configuration_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-module Draper
-  RSpec.describe Configuration do
-    it 'yields Draper on configure' do
-      Draper.configure { |config| expect(config).to be Draper }
-    end
-
-    describe '#default_controller' do
-      it 'defaults default_controller to ApplicationController' do
-        expect(Draper.default_controller).to be ApplicationController
-      end
-
-      it 'allows customizing default_controller through configure' do
-        default = Draper.default_controller
-
-        Draper.configure do |config|
-          config.default_controller = CustomController
-        end
-
-        expect(Draper.default_controller).to be CustomController
-
-        Draper.default_controller = default
-      end
-    end
-
-    describe '#default_query_methods_strategy' do
-      let!(:default) { Draper.default_query_methods_strategy }
-
-      subject { Draper.default_query_methods_strategy }
-
-      context 'when there is no custom strategy' do
-        it { is_expected.to eq(:active_record) }
-      end
-
-      context 'when using a custom strategy' do
-        before do
-          Draper.configure do |config|
-            config.default_query_methods_strategy = :mongoid
-          end
-        end
-
-        after { Draper.default_query_methods_strategy = default }
-
-        it { is_expected.to eq(:mongoid) }
-      end
-    end
-  end
-end

data/spec/draper/decoratable/equality_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples/decoratable_equality'
-
-module Draper
-  describe Decoratable::Equality do
-    describe "#==" do
-      it_behaves_like "decoration-aware #==", Object.new.extend(Decoratable::Equality)
-    end
-  end
-end