strong_presenter 0.0.1 → 0.1.0

data/spec/strong_presenter/permissions_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+module StrongPresenter
+  describe Permissions do
+    describe "#complete?" do
+      it 'is initially incomplete' do
+        expect(Permissions.new.complete?).to be false
+      end
+    end
+
+    describe "#permit_all!" do
+      it 'completes the object' do
+        expect(Permissions.new.permit_all!.complete?).to be true
+      end
+    end
+
+    describe "#permit" do
+      it 'permits an attribute' do
+        expect(Permissions.new.permit([], :attr).permitted?([], :attr)).to be true
+      end
+
+      it 'permits with prefix' do
+        expect(Permissions.new.permit(:prefix, :attr).permitted?(:prefix, :attr)).to be true
+      end
+
+      it 'permits with arrays of symbols' do
+        expect(Permissions.new.permit([:prefix, :array], [:attr, :array]).permitted?([:prefix, :array], [:attr, :array])).to be true
+      end
+
+      it 'permits multiple at once' do
+        permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
+        expect(permissions.permitted?([:prefix, :array], :attr2)).to be true
+        expect(permissions.permitted?([:prefix, :array], [:attr, :array])).to be true
+      end
+
+      it 'does not mutate arguments' do
+        prefix = [:pre, :fix]
+        attrpaths = [[:attr, :path], :s]
+        Permissions.new.permit(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+
+        expect(prefixarg).to eq prefix
+        expect(attrpathsarg).to eq attrpaths
+      end
+    end
+
+    describe "#permitted?" do
+      context 'with some attributes permitted' do
+        before(:all) do
+          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
+        end
+
+        it 'permits more specific paths' do
+          expect(@permissions.permitted?([:prefix, :array], [:attr2, :irrelevant])).to be true
+        end
+
+        it 'does not permit un-prefixed path' do
+          expect(@permissions.permitted?(:attr2)).to be false
+          expect(@permissions.permitted?([:attr2, :irrelevant])).to be false
+        end
+
+        it 'permits changed prefix boundaries' do
+          expect(@permissions.permitted?([:prefix, :array, :attr2], [:irrelevant])).to be true
+          expect(@permissions.permitted?(:prefix, [:array, :attr2, :irrelevant])).to be true
+          expect(@permissions.permitted?([:prefix], [:array, :attr2, :irrelevant])).to be true
+          expect(@permissions.permitted?([], [:prefix, :array, :attr2, :irrelevant])).to be true
+        end
+
+        it 'does not permit other attributes' do
+          expect(@permissions.permitted?([:prefix, :array], [:attr4, :irrelevant])).to be false
+        end
+
+        it 'does not permit shortened paths' do
+          expect(@permissions.permitted?([:prefix, :array], :attr)).to be false
+        end
+
+        it 'does not mutate arguments' do
+          prefix = [:pre, :fix]
+          attrpaths = [[:attr, :path], :s, [:array, :attr2]]
+
+          @permissions.permitted?(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+
+          prefix = [:prefix]
+          @permissions.permitted?(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+        end
+      end
+
+      context 'with permit all' do
+        it 'everything is true' do
+          permissions = Permissions.new.permit_all!
+          expect(permissions.permitted?(:a)).to be true
+          expect(permissions.permitted?([:a])).to be true
+          expect(permissions.permitted?([:a,:b])).to be true
+          expect(permissions.permitted?(:a,:b)).to be true
+          expect(permissions.permitted?([],:a)).to be true
+          expect(permissions.permitted?([],[:a])).to be true
+          expect(permissions.permitted?([:x,:y],[:a])).to be true
+          expect(permissions.permitted?([],[:a,:b])).to be true
+        end
+      end
+    end
+    describe "#select_permitted" do
+      context 'with some attributes permitted' do
+        before(:all) do
+          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
+          @permissions.permit([], [:attr, :array], :attr2, :attr3)
+        end
+
+        it 'can select something which is permitted' do
+          expect(@permissions.select_permitted([], :attr2)).to eq [[:attr2]]
+          expect(@permissions.select_permitted([:prefix], [:array, :attr2, :irrelevant])).to eq [[:array, :attr2, :irrelevant]]
+          expect(@permissions.select_permitted([:prefix, :array], [:attr2, :irrelevant])).to eq [[:attr2, :irrelevant]]
+        end
+
+        it 'can select multiple permitted attributes' do
+          attribute_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array]]
+          permitted = @permissions.select_permitted([:prefix, :array], *attribute_paths)
+          attribute_paths.each do |attribute_path|
+            expect(permitted).to include Array(attribute_path)
+          end
+        end
+
+        it 'selects only permitted attributes in the original order' do
+          permitted_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array], [:attr3, :ir]]
+          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar]]
+          attribute_paths = (unpermitted_paths + permitted_paths).shuffle
+          expect(@permissions.select_permitted([:prefix, :array], *attribute_paths)).to eq((attribute_paths & permitted_paths).map{|a|Array(a)})
+        end
+
+        it 'does not mutate arguments' do
+          prefix = [:pre, :fix]
+          attrpaths = [[:attr, :path], :s, [:array, :attr2]]
+
+          @permissions.select_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+
+          prefix = [:prefix]
+          @permissions.select_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+        end
+      end
+
+      context 'with permit all' do
+        it 'everything is selected' do
+          permissions = Permissions.new.permit_all!
+          attribute_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array]]
+          permitted = permissions.select_permitted([:prefix, :array], *attribute_paths)
+          expect(permitted).to eq(attribute_paths.map{|a|Array(a)})
+        end
+      end
+    end
+    describe "#reject_permitted" do
+      context 'with some attributes permitted' do
+        before(:all) do
+          @permissions = Permissions.new.permit([:prefix, :array], [:attr, :array], :attr2, :attr3)
+          @permissions.permit([], [:attr, :array], :attr2, :attr3)
+        end
+
+        it 'selects only unpermitted attributes in the original order' do
+          permitted_paths = [:attr2, :attr3, [:attr2, :irrelevant], [:attr, :array], [:attr3, :ir]]
+          unpermitted_paths = [:attr4, :attr5, [:attrk, :irrelevant], [:attr, :ar]]
+          attribute_paths = (unpermitted_paths + permitted_paths).shuffle
+          expect(@permissions.reject_permitted([:prefix, :array], *attribute_paths)).to eq((attribute_paths & unpermitted_paths).map{|a|Array(a)})
+        end
+
+        it 'does not mutate arguments' do
+          prefix = [:pre, :fix]
+          attrpaths = [[:attr, :path], :s, [:array, :attr2]]
+
+          @permissions.reject_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+
+          prefix = [:prefix]
+          @permissions.reject_permitted(prefixarg = prefix.dup, attrpathsarg = attrpaths.dup)
+          expect(prefixarg).to eq prefix
+          expect(attrpathsarg).to eq attrpaths
+        end
+      end
+    end
+  end
+end
+

data/spec/strong_presenter/presenter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module StrongPresenter
+  describe Presenter do
+    describe "#initialize" do
+      it "sets the object" do
+        object = Model.new
+        presenter = Presenter.new(object)
+
+        expect(presenter.send :object).to be object
+      end
+
+      it "takes a block" do
+        object = Product.new
+        presenter = ProductPresenter.new(object) do |presenter|
+          expect(presenter.class).to be ProductPresenter
+        end
+
+        expect(presenter.class).to be ProductPresenter
+      end
+    end
+
+    describe "Collection" do
+      it "finds corresponding collection presenter" do
+        expect(ProductPresenter::Collection).to be ProductsPresenter
+      end
+
+      it "creates a new collection presenter if one does not exist" do
+        expect{OthersPresenter}.to raise_error(NameError)
+        expect(OtherPresenter::Collection.superclass).to be StrongPresenter::CollectionPresenter
+        expect{OthersPresenter}.to raise_error(NameError)
+      end
+
+      it "sets inferred presenter on default collection presenter" do
+        expect(OtherPresenter::Collection.send :presenter_class).to be OtherPresenter
+      end
+
+      it "infers presenter on collection presenter" do
+        expect(ProductPresenter::Collection.send :presenter_class).to be ProductPresenter
+      end
+    end
+  end
+end

data/spec/strong_presenter/simplecov_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+SimpleCov.command_name 'spec:strong_presenter' if defined? SimpleCov
+

data/spec/support/dummy_app.rb

@@ -0,0 +1,85 @@
+require 'socket'
+require 'net/http'
+
+# Adapted from code by Jon Leighton
+# https://github.com/jonleighton/focused_controller/blob/ec7ccf1/test/acceptance/app_test.rb
+
+class DummyApp
+
+  def initialize(environment)
+    raise ArgumentError, "Environment must be development or production" unless ["development", "production"].include?(environment.to_s)
+    @environment = environment
+  end
+
+  attr_reader :environment
+
+  def url
+    "http://#{localhost}:#{port}"
+  end
+
+  def get(path)
+    Net::HTTP.get(URI(url + path))
+  end
+
+  def within_app(&block)
+    Dir.chdir(root, &block)
+  end
+
+  def start_server
+    within_app do
+      IO.popen("bundle exec rails s -e #{@environment} -p #{port} 2>&1") do |out|
+        start   = Time.now
+        started = false
+        output  = ""
+        timeout = 60.0
+
+        while !started && !out.eof? && Time.now - start <= timeout
+          output << read_output(out)
+          sleep 0.1
+
+          begin
+            TCPSocket.new(localhost, port)
+          rescue Errno::ECONNREFUSED
+          else
+            started = true
+          end
+        end
+
+        raise "Server failed to start:\n#{output}" unless started
+
+        yield
+
+        Process.kill("KILL", out.pid)
+        File.delete("tmp/pids/server.pid")
+      end
+    end
+  end
+
+  private
+
+  def root
+    File.expand_path("../../dummy", __FILE__)
+  end
+
+  def localhost
+    "127.0.0.1"
+  end
+
+  def port
+    @port ||= begin
+      server = TCPServer.new(localhost, 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+  end
+
+  def read_output(stream)
+    read = IO.select([stream], [], [stream], 0.1)
+    output = ""
+    loop { output << stream.read_nonblock(1024) } if read
+    output
+  rescue Errno::EAGAIN, Errno::EWOULDBLOCK, EOFError
+    output
+  end
+end

data/spec/support/matchers/have_text.rb

@@ -0,0 +1,50 @@
+require 'capybara'
+
+module HaveTextMatcher
+  def have_text(text)
+    HaveText.new(text)
+  end
+
+  class HaveText
+    def initialize(text)
+      @text = text
+    end
+
+    def in(css)
+      @css = css
+      self
+    end
+
+    def matches?(subject)
+      @subject = Capybara.string(subject)
+
+      @subject.has_css?(@css || "*", text: @text)
+    end
+
+    def failure_message_for_should
+      "expected to find #{@text.inspect} #{within}"
+    end
+
+    def failure_message_for_should_not
+      "expected not to find #{@text.inspect} #{within}"
+    end
+
+    private
+
+    def within
+      if @css && @subject.has_css?(@css)
+        "within\n#{@subject.find(@css).native}"
+      else
+        "#{inside} within\n#{@subject.native}"
+      end
+    end
+
+    def inside
+      @css ? "inside #{@css.inspect}" : "anywhere"
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include HaveTextMatcher
+end

data/spec/support/models.rb

@@ -0,0 +1,14 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+load File.dirname(__FILE__) + '/schema.rb'
+
+class Wheel < ActiveRecord::Base
+  belongs_to :vehicle, polymorphic: true
+end
+
+class Car < ActiveRecord::Base
+  has_many :wheels, as: :vehicle
+end
+

data/spec/support/schema.rb

@@ -0,0 +1,12 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :cars, :force => true do |t|
+    t.string :license_plate
+    t.timestamps
+  end
+  create_table :wheels, :force => true do |t|
+    t.references :vehicle, polymorphic: true
+    t.timestamps
+  end
+end

data/strong_presenter.gemspec

@@ -16,4 +16,19 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_dependency 'activesupport', '>= 3.0'
+  gem.add_dependency 'actionpack', '>= 3.0'
+  gem.add_dependency 'request_store', '~> 1.0.3'
+  gem.add_dependency 'activemodel', '>= 3.0'
+
+  gem.add_development_dependency 'ammeter'
+  gem.add_development_dependency 'rake', '>= 0.9.2'
+  gem.add_development_dependency 'rspec', '~> 2.12'
+  gem.add_development_dependency 'rspec-mocks', '>= 2.12.1'
+  gem.add_development_dependency 'rspec-rails', '~> 2.12'
+  gem.add_development_dependency 'minitest-rails', '~> 0.2'
+  gem.add_development_dependency 'capybara'
+  gem.add_development_dependency 'active_model_serializers'
+  gem.add_development_dependency 'activerecord', '>= 3.0'
 end