gift_wrap 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37ded86a1243c84591148c1c278126e00eca4c05
+  data.tar.gz: cc8f73fc149fdc246b96b43fa597d250562d429e
+SHA512:
+  metadata.gz: a1b13e46b2b4c1eae2aa13e6b5d3c386ae4c2efd211ca6b015c3c7e86edebd9e96ab8ba069e0dd51c9edf594ae7c6a7b5b9547ef0b11662b439af1300e65df46
+  data.tar.gz: 782ab93cb6d43ffdd15faa770ee183a06f94d56a05a0442c2df21adfce77dca24256ef8d4fbe8152a197f138ca40d9c8e3b27719618b3958cbf244bc318b2469

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    gift_wrap (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+    activerecord (4.2.6)
+      activemodel (= 4.2.6)
+      activesupport (= 4.2.6)
+      arel (~> 6.0)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ansi (1.5.0)
+    arel (6.0.3)
+    builder (3.2.2)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.9.0)
+    minitest-reporters (1.1.9)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    rake (10.5.0)
+    ruby-progressbar (1.8.1)
+    sqlite3 (1.3.11)
+    thread_safe (0.3.5)
+    turn-again-reporter (1.1.0)
+      minitest-reporters (~> 1.0, >= 1.0.8)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 4.0)
+  activerecord (~> 4.0, >= 4.0.0)
+  bundler (~> 1.7)
+  gift_wrap!
+  minitest-reporters (~> 1.1)
+  rake (~> 10.0)
+  sqlite3 (~> 1.3, >= 1.3.0)
+  turn-again-reporter (~> 1.1, >= 1.1.0)
+
+BUNDLED WITH
+   1.12.5

data/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Paul Kwiatkowski
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of adalog nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1 @@
+# GiftWrap

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs        << "test"
+  t.test_files  = Dir[File.join(File.dirname(__FILE__), 'test/**/*test.rb')]
+end

data/lib/gift_wrap.rb

@@ -0,0 +1,16 @@
+module GiftWrap
+
+  def self.config
+    @config ||= GiftWrap::Configuration.new
+  end
+
+
+  def self.configure
+    yield(config)
+  end
+
+end
+
+Dir[File.join(File.dirname(__FILE__), "gift_wrap", "*.rb")].each do |rb_file|
+  require rb_file
+end

data/lib/gift_wrap/active_record_presenter.rb

@@ -0,0 +1,54 @@
+module GiftWrap
+  module ActiveRecordPresenter
+
+    def self.included(base)
+      base.send(:include, ::GiftWrap::Presenter)
+      base.extend(::GiftWrap::ActiveRecordPresenter::ClassMethods)
+    end
+
+
+    module ClassMethods
+
+      ##
+      # Sets delegate methods via ::unwrap_for en masse for all columns.
+      # The :attribute keyword argument can specify which columns are attributes
+      # in one of three ways from different values:
+      # - true: all columns will be considered attributes
+      # - false: no columns will be considered attributes
+      # - A hash with the key :only, whose value specifies which columns to consider as
+      #   attributes, either singular or as an array of column names.
+      # - A hash with the key :except, whose value specifies which columns to consider as
+      #   attributes, either singular or as an array of column names.
+      def unwrap_columns_for(active_record_model, attribute: true, **options)
+        columns = active_record_model.columns.map { |col| col.name.to_sym }
+        if true == attribute || false == attribute
+          unwrap_for(*columns, attribute: attribute, **options)
+        elsif Hash === attribute
+          as_attributes, not_attributes = partition_columns_for_attributes(columns, attribute)
+          unwrap_for(*as_attributes,  attribute: true,  **options)
+          unwrap_for(*not_attributes, attribute: false, **options)
+        else
+          unwrap_for(*columns, attribute: attribute, **options)
+        end
+      end
+
+    private
+
+      def partition_columns_for_attributes(columns, attribute_options)
+        partitioned =
+          if attribute_options.key?(:only)
+            accepted_columns = [attribute_options.fetch(:only)].flatten
+            columns.partition { |col| accepted_columns.include?(col) }
+          elsif attribute_options.key?(:except)
+            rejected_columns = [attribute_options.fetch(:except)].flatten
+            columns.partition { |col| !rejected_columns.include?(col) }
+          else
+            [columns, []]
+          end
+        return *partitioned
+      end
+
+    end
+
+  end
+end

data/lib/gift_wrap/configuration.rb

@@ -0,0 +1,15 @@
+module GiftWrap
+  class Configuration
+
+    attr_accessor :use_serializers
+
+    def initialize
+      @use_serializers = !!defined?(ActiveModel)
+    end
+
+    def use_serializers?
+      @use_serializers
+    end
+
+  end
+end

data/lib/gift_wrap/presenter.rb

@@ -0,0 +1,126 @@
+module GiftWrap
+  module Presenter
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      if GiftWrap.config.use_serializers? && defined? ActiveModel::Serializers::JSON
+        base.send(:include, ActiveModel::Serializers::JSON)
+      end
+    end
+
+    ##
+    # Current options:
+    # - associations: a hash mapping association names to the presenter class
+    #   to use when wrapping the association. Used to override the :with setting of
+    #   a call to ::wrap_association at an instance level.
+    def initialize(wrapped_object, **options)
+      @wrapped_object                 = wrapped_object
+      @wrapped_association_presenters = options.fetch(:associations, {})
+    end
+
+    ##
+    # Used in methods defined by ::wrap_association to determine the presenter class that
+    # is used for a particular association name. First checks any instance-specific options
+    # for the association name, and falls back to those defined by the :with option passed
+    # to any ::wrap_association call for said association_name.
+    def wrapped_association_presenter(association_name)
+      if @wrapped_association_presenters.none?
+        self.class.wrapped_association_defaults.fetch(association_name) do |name|
+          raise NoMethodError.new("No association registered as '#{name}'.")
+        end
+      else
+        @wrapped_association_presenters.fetch(
+          association_name,
+          self.class.wrapped_association_defaults.fetch(association_name) do |name|
+            raise NoMethodError.new("No association registered as '#{name}'.")
+          end)
+      end
+    end
+
+    ##
+    # For use by ActiveModel::Serializers::JSON in building a default set of values
+    # when calling #as_json or #to_json
+    def attributes
+      self.class.attributes.each.with_object({}) do |msg, attr_hash|
+        attr_hash[msg.to_s] = self.send(msg)
+      end
+    end
+
+
+    module ClassMethods
+
+      ##
+      # Contains the of messages (which are used as hash keys) to send to self and collect
+      # when building an attributes hash.
+      def attributes
+        @attributes ||= Set.new
+      end
+
+      ##
+      # Contains the list of methods which will be delegated to the wrapped object rather than
+      # defined on presenter class itself.
+      def unwrapped_methods
+        @unwrapped_methods ||= Set.new
+      end
+
+      ##
+      # Contains the default settings for building any associations. These may be overridden
+      # on a per-intance basis.
+      def wrapped_association_defaults
+        @wrapped_association_defaults ||= {}
+      end
+
+      ##
+      # Defines a private method name by which the wrapped object may be referenced internally.
+      def wrapped_as(reference)
+        define_method(reference) do
+          @wrapped_object
+        end
+        send(:private, reference)
+      end
+
+      ##
+      # Declares one or more messages (method names) to be attributes.
+      def attribute(*names)
+        names.flatten.each do |name|
+          attributes << name
+        end
+      end
+
+      ##
+      # Declares that one or more received messages (method calls) should be delegated directly
+      # to the wrapped object, and which may be optionally declared as attributes.
+      #
+      def unwrap_for(*names, attribute: false, **options)
+        names = names.flatten
+        names.each do |name|
+          unwrapped_methods << name
+          attributes        << name if attribute
+        end
+        delegate(*names, to: :@wrapped_object)
+      end
+
+      ##
+      # Declares that the result of a delegated method call should be wrapped in another
+      # presenter, as defined by the :with keyword argument.
+      # This results in a method by the name of the first parameter by default, but may be
+      # customized with the :as keyword argument.
+      # Associations whose method produces an enumerable (ideally an Array) will have each
+      # item wrapped in the presenter and collected in an Array which is then returned.
+      def wrap_association(association, with: , as: association, **options)
+        wrapped_association_defaults[as] = with
+        define_method(as) do
+          presenter_class = wrapped_association_presenter(as)
+          associated      = @wrapped_object.send(association)
+          if associated.respond_to?(:each)
+            associated.map { |assoc| presenter_class.new(assoc, **options) }
+          else
+            presenter_class.new(associated, **options)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/gift_wrap/version.rb

@@ -0,0 +1,3 @@
+module GiftWrap
+  VERSION = '0.2.0'
+end

data/test/database/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users, :force => true do |t|
+    t.string  :email
+    t.string  :first_name
+    t.string  :last_name
+    t.string  :encrypted_password
+    t.integer :sign_in_count
+
+    t.timestamps null: false
+  end
+
+end

data/test/domain/legend.rb

@@ -0,0 +1,18 @@
+##
+# An object to associate with a map, for testing associations & wrapping thereof.
+class Legend
+
+  def initialize(colored_regions, colored_lines)
+    @colored_regions  = colored_regions
+    @colored_lines    = colored_lines
+  end
+
+  def region_meaning(color)
+    @colored_regions[color]
+  end
+
+  def line_meaning(color)
+    @colored_lines[color]
+  end
+
+end

data/test/domain/map.rb

@@ -0,0 +1,26 @@
+##
+# Everyone loves maps.
+class Map
+
+  attr_reader :type, :center, :units, :legend
+  attr_accessor :notes
+
+  def initialize(type, center, units, legend = :asshole_mapmaker_forgot_legend)
+    @type   = type
+    @center = center
+    @units  = units
+    @notes  = ""
+    @legend = legend
+  end
+
+  def shows_roads?
+    maps_with_roads.include?(type)
+  end
+
+private
+
+  def maps_with_roads
+    ['road', 'traffic', 'political']
+  end
+
+end

data/test/domain/user.rb

@@ -0,0 +1,7 @@
+class User < ActiveRecord::Base
+
+  def initials
+    "#{first_name[0]}#{last_name[0]}"
+  end
+
+end

data/test/fixtures/user_records.rb

@@ -0,0 +1,37 @@
+module UserRecords
+
+  def self.create!
+    users_attributes.each do |attrs|
+      User.create(attrs)
+    end
+  end
+
+
+  def self.temporal_reference_point
+    @temporal_reference_point ||= Time.now
+  end
+
+
+  def self.users_attributes
+    [ { id:                 1,
+        email:              "paulwall@example.com",
+        first_name:         "Paul",
+        last_name:          "Wall",
+        encrypted_password: "$2a$10$DbRvyFxovWAly4ZCDtcJ6uVhbMGya2iGiLCURhSwM1ZGUyXpM5UiW",
+        sign_in_count:      2,
+        created_at:         temporal_reference_point,
+        updated_at:         temporal_reference_point,
+      },
+      { id:                 2,
+        email:              "gendoarrighetti@example.com",
+        first_name:         "Gendo",
+        last_name:          "Arrighetti",
+        encrypted_password: "$2a$10$DbRvyFxovWAly4ZCDtcJ6uVhbMGya2iGiLCURhSwM1ZGUyXpM5UiW",
+        sign_in_count:      0,
+        created_at:         temporal_reference_point,
+        updated_at:         temporal_reference_point,
+      },
+    ]
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,70 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/reporters/turn_again_reporter'
+Minitest::Reporters.use!(Minitest::Reporters::TurnAgainReporter.new)
+
+##
+# The following active_support and active_model files are the specific minimum
+# dependencies for using ActiveModel::Serializers::JSON
+require 'active_support/json'
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+require 'active_model/naming'
+require 'active_model/serialization'
+require 'active_model/serializers/json'
+
+##
+# And of course, require ourselves.
+require 'gift_wrap'
+
+##
+# Blatantly stolen from ActiveSupport::Testing::Declarative
+# Allows for test files such as
+#   test "verify something" do
+#     ...
+#   end
+# which become methods named test_verify_something, leaving a visual difference
+# between tests themselves and any helper methods declared in the usual
+# manner of `def some_helper_method`.
+module DeclarativeTests
+  def test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+end
+
+class Minitest::Test
+  extend DeclarativeTests
+end
+
+##
+# ActiveRecord setup for testing use of GiftWrap::ActiveRecordPresenter
+#
+# TODO (possibly):
+#   Have some sort of method for switching on/off inclusion and execution
+#   of active_record in tests. The goal would be to ensure that no tests
+#   unrelated to ActiveRecord accidentally come to rely on its presence, or on
+#   the presence of the friends it pulls in (ActiveModel, ActiveSupport).
+#
+# Some ordering of some of these steps is important:
+#   1. Set up in-memory sqlite3 connection.
+#   2. Require the model class.
+#   3. Load the database schema. Doing this before loading the model broke things?
+#   4. Load a file that creates some user rows and run said creation method.
+require 'active_record'
+require 'sqlite3'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+require File.join(File.dirname(__FILE__), "domain", "user.rb")
+require File.join(File.dirname(__FILE__), "database", "schema.rb")
+require File.join(File.dirname(__FILE__), "fixtures", "user_records.rb")
+UserRecords.create!

data/test/unit/active_record_presenter_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+class ActiveRecordPresenterTest < Minitest::Test
+
+## Test Implementation Classes #################################################
+
+
+  class SimpleUserPresenter
+    include GiftWrap::ActiveRecordPresenter
+
+    unwrap_columns_for ::User
+
+    unwrap_for :initials
+
+    def email_with_display_name
+      "#{first_name} #{last_name} <#{email}>"
+    end
+
+  end
+
+
+  class NoAttributeUserPresenter
+    include GiftWrap::ActiveRecordPresenter
+    unwrap_columns_for ::User, attribute: false
+  end
+
+
+  class UserPresenterUsingOnly
+    include GiftWrap::ActiveRecordPresenter
+    unwrap_columns_for ::User, attribute: { only: [:first_name, :email, :last_name] }
+  end
+
+
+  class UserPresenterUsingExcept
+    include GiftWrap::ActiveRecordPresenter
+    unwrap_columns_for ::User, attribute: { except: [:first_name, :email, :last_name] }
+  end
+
+
+## Setup Helpers #########################################################
+
+
+  def sample_user
+    User.find(1)
+  end
+
+
+## Test Cases ##################################################################
+
+
+  test "can unwrap columns" do
+    paulwall  = sample_user
+    presenter = SimpleUserPresenter.new(paulwall)
+    assert(presenter.respond_to?(:email))
+    assert(presenter.respond_to?(:first_name))
+    assert(presenter.respond_to?(:encrypted_password))
+    assert_equal(paulwall.email, presenter.email)
+  end
+
+
+  test "can respond to additional instance methods" do
+    paulwall  = sample_user
+    presenter = SimpleUserPresenter.new(paulwall)
+    assert_equal("Paul Wall <paulwall@example.com>", presenter.email_with_display_name)
+  end
+
+
+  test "can wrap methods as expected of a presenter" do
+    paulwall  = sample_user
+    presenter = SimpleUserPresenter.new(paulwall)
+    assert_equal("PW", paulwall.initials)
+    assert_equal("PW", presenter.initials)
+  end
+
+
+  test "columns are set as presenter attributes by default" do
+    paulwall  = sample_user
+    presenter = SimpleUserPresenter.new(paulwall)
+    assert_includes(presenter.attributes.keys, 'email')
+    assert_includes(presenter.attributes.keys, 'created_at')
+    assert_includes(presenter.attributes.keys, 'updated_at')
+    assert_includes(presenter.attributes.keys, 'first_name')
+    assert_includes(presenter.attributes.keys, 'last_name')
+    assert_includes(presenter.attributes.keys, 'sign_in_count' )
+  end
+
+
+  test "unwrap_columns_for can be asked to set no columns as attributes" do
+    presenter = NoAttributeUserPresenter.new(sample_user)
+    assert_equal({}, presenter.attributes)
+  end
+
+
+  test "unwrap_columns_for can specify attributes with :only" do
+    presenter = UserPresenterUsingOnly.new(sample_user)
+    assert_includes(presenter.attributes.keys, 'email')
+    assert_includes(presenter.attributes.keys, 'first_name')
+    assert_includes(presenter.attributes.keys, 'last_name')
+    refute_includes(presenter.attributes.keys, 'created_at')
+    refute_includes(presenter.attributes.keys, 'updated_at')
+    refute_includes(presenter.attributes.keys, 'sign_in_count')
+  end
+
+
+  test "unwrap_columns_for can specify attributes with :except" do
+    presenter = UserPresenterUsingExcept.new(sample_user)
+    assert_includes(presenter.attributes.keys, 'created_at')
+    assert_includes(presenter.attributes.keys, 'updated_at')
+    assert_includes(presenter.attributes.keys, 'sign_in_count')
+    refute_includes(presenter.attributes.keys, 'email')
+    refute_includes(presenter.attributes.keys, 'first_name')
+    refute_includes(presenter.attributes.keys, 'last_name')
+  end
+
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+require 'domain/map'
+require 'domain/legend'
+
+class ConfigurationTest < Minitest::Test
+
+## Setup Helpers #################################################
+
+  ##
+  # Since we're reconfiguring module-wide settings, we can't rely on a class defined
+  # at load time to pick up on changes to the configuration during successive test cases.
+  def build_presenter_class
+    Class.new do
+      include GiftWrap::Presenter
+      unwrap_for :type
+      unwrap_for :units, attribute: true
+    end
+  end
+
+
+## Test Cases ##################################################################
+
+
+  test "presenters include serializers when use_serializers is true" do
+    GiftWrap.configure do |config|
+      config.use_serializers = true
+    end
+    map       = Map.new("physical", ["here", "there"], "mi")
+    presenter = build_presenter_class.new(map)
+    assert_kind_of(ActiveModel::Serializers::JSON, presenter)
+  end
+
+
+  test "presenters do not include serializers when use_serializers is false" do
+    GiftWrap.configure do |config|
+      config.use_serializers = false
+    end
+    map       = Map.new("physical", ["here", "there"], "mi")
+    presenter = build_presenter_class.new(map)
+    refute_kind_of(ActiveModel::Serializers::JSON, presenter)
+  end
+
+end

data/test/unit/presenter_test.rb

@@ -0,0 +1,259 @@
+require 'test_helper'
+require 'domain/map'
+require 'domain/legend'
+
+class PresenterTest < Minitest::Test
+
+## Test Implementation Classes #################################################
+
+
+  ##
+  # A presenter which adds a few new methods and attributes to a given Map.
+  class SimpleMapPresenter
+    include GiftWrap::Presenter
+
+    attribute :metric?
+
+    unwrap_for :type
+    unwrap_for :units, attribute: true
+
+    def metric?
+      metric_map_units.include?(units)
+    end
+
+    def contains_region?(region_name)
+      false # Implementation not important
+    end
+
+    private
+
+    def metric_map_units
+      ['m', 'km']
+    end
+
+  end
+
+  ##
+  # Gives an explicit name to the wrapped object for reference
+  # internally to the class, and has a method which uses that reference
+  # for use in proving that an internal reference is functioning.
+  class ExplicitReferencePresenter
+    include GiftWrap::Presenter
+
+    wrapped_as :explicit_reference
+
+    def uses_explicit_reference(msg_name)
+      explicit_reference.send(msg_name)
+    end
+
+  end
+
+  ##
+  # Presenter intended to work with a Legend.
+  class LegendPresenter
+    include GiftWrap::Presenter
+
+    unwrap_for :line_meaning
+
+    attribute :red_lines
+
+    def red_lines
+      line_meaning(:red)
+    end
+
+    def yellow_lines
+      line_meaning(:yellow)
+    end
+
+    def green_lines
+      line_meaning(:green)
+    end
+
+  end
+
+  ##
+  # Map Presenter which wraps its :legend association, for use in testing associations
+  # being wrapped in a presenter of their own.
+  class LegendaryMapPresenter
+    include GiftWrap::Presenter
+
+    unwrap_for :type, :units
+
+    wrap_association :legend, with: LegendPresenter
+
+    def metric?
+      metric_map_units.include?(units)
+    end
+
+    private
+
+    def metric_map_units
+      ['m', 'km']
+    end
+
+  end
+
+  ##
+  # Another presenter for legends as an alternative to test if overriding association
+  # presenters on a per-instance basis functions.
+  class MisleadingLegendPresenter
+    include GiftWrap::Presenter
+
+    unwrap_for :line_meaning
+
+    def red_lines
+      "no congestion"
+    end
+
+    def yellow_lines
+      "no congestion"
+    end
+
+    def green_lines
+      "no congestion"
+    end
+
+  end
+
+  ##
+  # Map Presenter which wraps its :legend association with the name :foobar
+  class FoobarLegendMapPresenter
+    include GiftWrap::Presenter
+
+    unwrap_for :type, :units
+
+    wrap_association :legend, with: LegendPresenter, as: :foobar
+
+    def metric?
+      metric_map_units.include?(units)
+    end
+
+    private
+
+    def metric_map_units
+      ['m', 'km']
+    end
+
+  end
+
+
+## Setup Helpers #########################################################
+
+
+  def physical_map
+    Map.new("physical", ["here", "there"], "mi")
+  end
+
+
+  def map_with_legend
+    Map.new("traffic", "downtown", "km", traffic_legend)
+  end
+
+
+  def traffic_legend
+    Legend.new(
+      { beige:  "land",
+        blue:   "water"
+      },
+      { green:  "no congestion",
+        yellow: "light congestion",
+        red:    "heavy congestion",
+        black:  "impassable"
+      })
+  end
+
+
+## Test Cases ##################################################################
+
+
+  test "unwrapped methods are delegated properly" do
+    map       = physical_map
+    presenter = SimpleMapPresenter.new(map)
+    assert_equal(map.type, presenter.type)
+    assert_equal(map.units, presenter.units)
+  end
+
+
+  test "methods not explicitly unwrapped are not accessible" do
+    map       = physical_map
+    presenter = SimpleMapPresenter.new(map)
+    assert(map.respond_to?(:center))
+    refute(presenter.respond_to?(:center))
+  end
+
+
+  test "attributes can include unwrapped methods" do
+    attributes = SimpleMapPresenter.new(physical_map).attributes
+    assert_includes(attributes.keys, 'units')
+  end
+
+
+  test "attributes do not include unwrapped methods by default" do
+    attributes = SimpleMapPresenter.new(physical_map).attributes
+    refute_includes(attributes.keys, 'type')
+  end
+
+
+  test "attributes hash include explicitly declared attributes" do
+    attributes = SimpleMapPresenter.new(physical_map).attributes
+    assert_includes(attributes.keys, 'metric?')
+  end
+
+
+  test "can reference a wrapped object internally via wrapped_as name" do
+    map       = physical_map
+    presenter = ExplicitReferencePresenter.new(map)
+    assert_equal(map.type, presenter.uses_explicit_reference(:type))
+    assert_equal(map.units, presenter.uses_explicit_reference(:units))
+    assert_raises(NoMethodError) do |variable|
+      presenter.explicit_reference
+    end
+  end
+
+
+  test "associations can be wrapped with their own presenter class" do
+    map       = map_with_legend
+    presenter = LegendaryMapPresenter.new(map)
+    assert(map.respond_to?(:legend))
+    assert(presenter.respond_to?(:legend))
+    assert(LegendPresenter === presenter.legend)
+    assert(presenter.legend.respond_to?(:line_meaning))
+    assert(presenter.legend.respond_to?(:red_lines))
+    refute_includes(presenter.legend.attributes.keys, 'line_meaning')
+    assert_includes(presenter.legend.attributes.keys, 'red_lines')
+    assert_equal(presenter.legend.green_lines, 'no congestion')
+    assert_equal(presenter.legend.red_lines, 'heavy congestion')
+  end
+
+
+  test "associations' class can be specified on a per-instance basis" do
+    map       = map_with_legend
+    presenter = LegendaryMapPresenter.new(map, associations: {
+      legend: MisleadingLegendPresenter
+    })
+    assert(map.respond_to?(:legend))
+    assert(presenter.respond_to?(:legend))
+    assert(MisleadingLegendPresenter === presenter.legend)
+    assert(presenter.legend.respond_to?(:line_meaning))
+    assert(presenter.legend.respond_to?(:red_lines))
+    assert_equal(presenter.legend.green_lines, 'no congestion')
+    assert_equal(presenter.legend.red_lines, 'no congestion')
+  end
+
+
+  test "associations' name can be something other than assoication name" do
+    map       = map_with_legend
+    presenter = FoobarLegendMapPresenter.new(map)
+    assert(map.respond_to?(:legend))
+    assert(presenter.respond_to?(:foobar))
+    assert(LegendPresenter === presenter.foobar)
+    # Most of this mirrors the other association tests for good measure.
+    assert(presenter.foobar.respond_to?(:line_meaning))
+    assert(presenter.foobar.respond_to?(:red_lines))
+    refute_includes(presenter.foobar.attributes.keys, 'line_meaning')
+    assert_includes(presenter.foobar.attributes.keys, 'red_lines')
+    assert_equal(presenter.foobar.green_lines, 'no congestion')
+    assert_equal(presenter.foobar.red_lines, 'heavy congestion')
+  end
+
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: gift_wrap
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Paul Kwiatkowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: turn-again-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: A simple Ruby presenter library, for those who enjoy a strong separation
+  of concerns. You include a module, call some class-level macro-style methods, and
+  suddenly you're presenting for a wrapped object. No magic. If your knowledge of
+  pattern names comes from the Rails ecosystem, you might have used the popular Draper
+  'decorator' library. Think of this like that one, except the term 'presenter' is
+  a better fit.
+email:
+- paul@groupraise.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/gift_wrap.rb
+- lib/gift_wrap/active_record_presenter.rb
+- lib/gift_wrap/configuration.rb
+- lib/gift_wrap/presenter.rb
+- lib/gift_wrap/version.rb
+- test/database/schema.rb
+- test/domain/legend.rb
+- test/domain/map.rb
+- test/domain/user.rb
+- test/fixtures/user_records.rb
+- test/test_helper.rb
+- test/unit/active_record_presenter_test.rb
+- test/unit/configuration_test.rb
+- test/unit/presenter_test.rb
+homepage: https://github.com/swifthand/adalog
+licenses:
+- Revised BSD, see LICENSE.md
+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.4.8
+signing_key: 
+specification_version: 4
+summary: A simple Ruby presenter library, for those who enjoy a strong separation
+  of concerns.
+test_files:
+- test/database/schema.rb
+- test/domain/legend.rb
+- test/domain/map.rb
+- test/domain/user.rb
+- test/fixtures/user_records.rb
+- test/test_helper.rb
+- test/unit/active_record_presenter_test.rb
+- test/unit/configuration_test.rb
+- test/unit/presenter_test.rb