rails_view_adapters 0.2.1

data/lib/rails_view_adapters.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "active_support/core_ext/time"
+Time.zone = "UTC"
+
+require "rails_view_adapters/version"
+require "rails_view_adapters/adapter_base"
+require "rails_view_adapters/map"
+require "rails_view_adapters/definition_proxy"
+require "rails_view_adapters/adapter"
+
+# Namespace for rails_view_adapters
+module RailsViewAdapters
+end

data/rails_view_adapters.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_view_adapters/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_view_adapters"
+  spec.version       = RailsViewAdapters::VERSION
+  spec.authors       = ["Bryan Hockey"]
+  spec.email         = ["bhock@umich.edu"]
+
+  spec.summary       = "Bidirectional mappings between models and external views for Rails."
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/mlibrary/rails_view_adapters"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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.test_files = Dir["spec/**/*"]
+
+  spec.required_ruby_version = ">= 2.2.2"
+
+  spec.add_dependency "activerecord", "~>4.2.7.1"
+  spec.add_dependency "activesupport", "~>4.2.7.1"
+
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "faker"
+  spec.add_development_dependency "fabrication"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rubocop"
+end

data/spec/active_record_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "active_record"
+require "fabrication"
+
+require "active_record_support/models/user"
+require "active_record_support/models/post"
+require "active_record_support/models/team"
+
+require "active_record_support/fabricators/user_fabricator"
+require "active_record_support/fabricators/post_fabricator"
+require "active_record_support/fabricators/team_fabricator"
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveSupport::Deprecation.silenced = true
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Migrator.migrate File.join(File.dirname(__FILE__), "active_record_support/db/migrate")

data/spec/active_record_support/db/migrate/20161031222934_create_users.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.string :name
+      t.time :join_date
+      t.string :secret
+      t.boolean :admin
+      t.references :team, foreign_key: true
+
+      t.timestamps
+    end
+  end
+end

data/spec/active_record_support/db/migrate/20161031223219_create_posts.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+class CreatePosts < ActiveRecord::Migration
+  def change
+    create_table :posts do |t|
+      t.text :body
+      t.references :user, foreign_key: true
+
+      t.timestamps
+    end
+  end
+end

data/spec/active_record_support/db/migrate/20161031223253_create_teams.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+class CreateTeams < ActiveRecord::Migration
+  def change
+    create_table :teams do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end

data/spec/active_record_support/fabricators/post_fabricator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require "faker"
+
+Fabricator(:post) do
+  body { Faker::Lorem.paragraph }
+  user { Fabricate(:user) }
+end

data/spec/active_record_support/fabricators/team_fabricator.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "faker"
+
+Fabricator(:team) do
+  name { Faker::Company.name }
+end

data/spec/active_record_support/fabricators/user_fabricator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require "faker"
+
+Fabricator(:user) do
+  name      { Faker::Name.name }
+  join_date { Faker::Time.between(2.years.ago, Time.now) }
+  secret    { Faker::Internet.password }
+  admin     false
+  team      { Fabricate(:team) }
+end

data/spec/active_record_support/models/post.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class Post < ActiveRecord::Base
+  belongs_to :user
+end

data/spec/active_record_support/models/team.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class Team < ActiveRecord::Base
+  has_many :users
+end

data/spec/active_record_support/models/user.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+class User < ActiveRecord::Base
+  belongs_to :team
+  has_many :posts
+end

data/spec/integration/an_adapter_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "active_record_helper"
+require "spec_helper"
+
+module RailsViewAdapters
+
+  describe "an adapter", integration: true do
+    date_format = "%Y-%m-%dT%H:%M:%S%z"
+    secret_token = Faker::Internet.password
+    Adapter.define(:user_integration_test_adapter) do
+      map_simple :name, :author
+      map_date :join_date, :member_since, date_format
+      map_date :created_at, :created_at, date_format
+      map_date :updated_at, :updated_at, date_format
+      map_bool :admin, :super_user
+      hidden_field :secret
+      map_from_public :secret do |token|
+        { secret: token }
+      end
+      map_belongs_to :team, :favorite_team, model_class: Team
+      map_has_many :posts, :all_posts, sub_method: :body
+    end
+
+    before(:each) do
+      @model = Fabricate(:user, secret: secret_token)
+      Fabricate.times(3, :post, user: @model)
+
+      @public_hash = {
+        author: @model.name,
+        member_since: @model.join_date.in_time_zone.strftime(date_format),
+        super_user: @model.admin,
+        favorite_team: @model.team.id,
+        all_posts: @model.posts.pluck(:body),
+        created_at: @model.created_at.in_time_zone.strftime(date_format),
+        updated_at: @model.updated_at.in_time_zone.strftime(date_format)
+      }
+
+      @model_hash = {
+        name: @model.name,
+        join_date: @model.join_date,
+        admin: @model.admin,
+        secret: @model.secret,
+        team_id: @model.team_id,
+        posts: @model.posts,
+        created_at: @model.created_at,
+        updated_at: @model.updated_at
+      }
+    end
+
+    it_behaves_like "an adapter", secret: secret_token do
+      let(:adapter_class) { UserIntegrationTestAdapter }
+      let(:model)         { @model }
+      let(:public_hash)   { @public_hash }
+      let(:model_hash)    { @model_hash }
+    end
+  end
+
+end

data/spec/lib/adapter_base_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "active_record_helper"
+
+module RailsViewAdapters
+  describe AdapterBase do
+    class TestAdapter < AdapterBase
+      def self.simple_maps
+        [[:body, :post_text]]
+      end
+
+      def self.to_maps
+        [[:user_id, proc {|v| { user_name: v + 10 } }]]
+      end
+
+      def self.from_maps
+        [[:user_name, proc {|v| { user_id: v + 100 } }]]
+      end
+
+      def self.model_fields
+        [:body, :user_id]
+      end
+
+      def self.public_fields
+        [:post_text, :user_name]
+      end
+    end
+
+    class ARTestAdapter < TestAdapter
+      def self.to_maps
+        [[:user_id, proc {|v| { user_name: User.find(v).name } }]]
+      end
+
+      def self.from_maps
+        [[:user_name, proc {|v| { user_id: User.find_by_name(v).id } }]]
+      end
+    end
+
+    describe "#to_model_hash" do
+      let(:internals) { { a: 1, b: 2 } }
+      it "returns the internals" do
+        expect(described_class.new(internals, {}).to_model_hash).to eql(internals)
+      end
+    end
+
+    describe "#to_params_hash" do
+      let(:internals) { { a: 1, b: 2 } }
+      let(:disjoint_extras) { { c: 3 } }
+      let(:overlapping_extras) { { b: 27, c: 3 } }
+      it "merges internals and extras" do
+        expect(described_class.new(internals, disjoint_extras).to_params_hash)
+          .to eql(a: 1, b: 2, c: 3)
+      end
+      it "prefers internals over extras" do
+        expect(described_class.new(internals, overlapping_extras).to_params_hash)
+          .to eql(a: 1, b: 2, c: 3)
+      end
+      it "symbolizes keys" do
+        expect(described_class.new(internals, "c" => 3).to_params_hash)
+          .to eql(a: 1, b: 2, c: 3)
+      end
+    end
+
+    describe "#to_public_hash" do
+      let(:internals) { { body: 2, user_id: 4 } }
+      let(:extras) { { extra_field: "asdf" } }
+      let(:adapter) { TestAdapter.new(internals, extras) }
+      it "returns the public hash w/o extras" do
+        expect(adapter.to_public_hash).to eql(
+          post_text: 2,
+          user_name: 14
+        )
+      end
+    end
+
+    describe "#to_json" do
+      let(:adapter) { described_class.new({}, {}) }
+      let(:public_hash) { double(:public_hash) }
+      let(:options) { { a: 11_313, b: 1231 } }
+      it "delegates to #to_json on the public hash" do
+        allow(adapter).to receive(:to_public_hash).and_return(public_hash)
+        expect(public_hash).to receive(:to_json).with(options)
+        adapter.to_json(options)
+      end
+    end
+
+    describe "::from_model" do
+      let(:model) { Fabricate(:post) }
+      it "instantiates the adapter" do
+        expect(TestAdapter.from_model(model)).to be_an_instance_of(TestAdapter)
+      end
+      it "loads the model as its internals" do
+        expect(TestAdapter.from_model(model).to_model_hash).to eql(
+          body: model.body,
+          user_id: model.user_id
+        )
+      end
+    end
+
+    describe "::from_public" do
+      let(:user) { Fabricate(:user) }
+      let(:input_hash) do
+        {
+          post_text: Faker::Lorem.paragraph,
+          user_name: user.name,
+          extra_field: 12_345
+        }
+      end
+      it "instantiates the adapter" do
+        expect(ARTestAdapter.from_public(input_hash)).to be_an_instance_of(ARTestAdapter)
+      end
+      it "loads the internals" do
+        expect(ARTestAdapter.from_public(input_hash).to_model_hash).to eql(
+          body: input_hash[:post_text],
+          user_id: user.id
+        )
+      end
+      it "loads the extras" do
+        expect(ARTestAdapter.from_public(input_hash).to_params_hash).to eql(
+          body: input_hash[:post_text],
+          user_id: user.id,
+          extra_field: 12_345
+        )
+      end
+      it "doesn't mutate the public representation" do
+        expect(ARTestAdapter.from_public(input_hash).to_public_hash).to eql(
+          post_text: input_hash[:post_text],
+          user_name: input_hash[:user_name]
+        )
+      end
+    end
+  end
+end

data/spec/lib/adapter_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+module RailsViewAdapters
+  describe Adapter do
+    describe "::define" do
+      it "defines a new class" do
+        Adapter.define(:new_test_adapter) {}
+        expect do
+          Object.const_get("NewTestAdapter")
+        end.to_not raise_error
+      end
+
+      it "sets the constant equal to the created adapter" do
+        spy = double(:spy)
+        allow(Adapter).to receive(:adapter_from_map).and_return(spy)
+        Adapter.define(:even_newer) {}
+        expect(EvenNewer).to eql(spy)
+      end
+    end
+
+    describe "::adapter_from_map" do
+      let(:map) do
+        double(:map,
+          model_fields: [:m1, :m2],
+          public_fields: [:p1, :p2],
+          simple_maps: [[:m1, :p1]],
+          to_maps: [[:m2, double(:proc1)]],
+          from_maps: [[:p2, double(:proc2)]])
+      end
+      let(:adapter) { Adapter.adapter_from_map(map) }
+      it "returns a new class" do
+        expect(adapter).to be_a(Class)
+      end
+      it "inherits from AdapterBase" do
+        expect(adapter).to be <= AdapterBase
+      end
+      [:model_fields, :public_fields, :simple_maps, :to_maps, :from_maps].each do |field|
+        it "adds the ::#{field} method" do
+          expect(adapter.public_send(field)).to eql(map.public_send(field))
+        end
+      end
+    end
+  end
+end

data/spec/lib/definition_proxy_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "active_record_helper"
+
+module RailsViewAdapters
+
+  class TestMap < Map
+    def to_hash
+      {
+        model_fields: model_fields,
+        public_fields: public_fields,
+        simple_maps: simple_maps,
+        to_maps: to_maps,
+        from_maps: from_maps
+      }
+    end
+  end
+
+  describe DefinitionProxy do
+    let(:proxy) { described_class.new(TestMap.new) }
+    let(:bare_hash) do
+      {
+        model_fields: [],
+        public_fields: [],
+        simple_maps: [],
+        to_maps: [],
+        from_maps: []
+      }
+    end
+
+    describe "#map_simple" do
+      let(:model_field) { :mod }
+      let(:public_field) { :pub }
+      it "creates the correct mapping" do
+        proxy.map_simple(model_field, public_field)
+        expect(proxy.map.to_hash).to eql(bare_hash.merge(
+          public_fields: [public_field],
+          model_fields: [model_field],
+          simple_maps: [[model_field, public_field]]
+        ))
+      end
+    end
+
+    describe "#map_to_public" do
+      let(:model_field) { :mod }
+      let(:extra_fields) { [:one, :two] }
+      let(:process) { proc {|v| { one: v + 1, two: v + 2 } } }
+      it "creates the correct mapping" do
+        proxy.map_to_public(model_field, extra_fields, &process)
+        expect(proxy.map.to_hash).to eql(bare_hash.merge(
+          to_maps: [[model_field, process]],
+          public_fields: extra_fields,
+          model_fields: [model_field]
+        ))
+      end
+    end
+
+    describe "#map_from_public" do
+      let(:public_field) { :pub }
+      let(:process) { proc {|v| { one: v + 1, two: v + 2 } } }
+      it "creates the correct mapping" do
+        proxy.map_from_public(public_field, &process)
+        expect(proxy.map.to_hash).to eql(bare_hash.merge(
+          from_maps: [[public_field, process]],
+          public_fields: [public_field]
+        ))
+      end
+    end
+
+    describe "#hidden_field" do
+      let(:hidden_field) { :hidden }
+      it "adds a model_field" do
+        proxy.hidden_field(hidden_field)
+        expect(proxy.map.to_hash).to eql(bare_hash.merge(
+          model_fields: [hidden_field]
+        ))
+      end
+    end
+
+    describe "#map_date" do
+      let(:model_field) { :mod }
+      let(:public_field) { :pub }
+      let(:date_format) { "%Y-%m-%dT%H:%M:%SZ" }
+      let(:time) { Time.new(2016, 10, 31, 12, 25, 33).utc }
+      let(:time_string) { time.strftime(date_format) }
+      it "creates the correct model_fields" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.model_fields).to eql([model_field])
+      end
+      it "creates the correct public_fields" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.public_fields).to eql([public_field])
+      end
+      it "creates no simple_maps" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.simple_maps).to eql([])
+      end
+      it "creates the correct to_maps" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.to_maps[0]).to contain_exactly(model_field, an_instance_of(Proc))
+      end
+      it "creates the correct from_maps" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.from_maps[0]).to contain_exactly(public_field, an_instance_of(Proc))
+      end
+      it "defines a to_map that converts the model's date to the public's string" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.to_maps[0][1].call(time)).to eql(public_field => time_string)
+      end
+      it "defines a from_map that converts the public's string to the model's Time" do
+        proxy.map_date(model_field, public_field, date_format)
+        expect(proxy.map.from_maps[0][1].call(time_string)).to eql(model_field => time)
+      end
+      it "raises ArgumentError if date_format is nil" do
+        expect do
+          proxy.map_date(model_field, public_field, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    describe "#map_bool" do
+      let(:model_field) { :mod }
+      let(:public_field) { :pub }
+      it "creates the correct model_fields" do
+        proxy.map_bool(model_field, public_field)
+        expect(proxy.map.model_fields).to eql([model_field])
+      end
+      it "creates the correct public_fields" do
+        proxy.map_bool(model_field, public_field)
+        expect(proxy.map.public_fields).to eql([public_field])
+      end
+      it "creates the correct to_maps" do
+        proxy.map_bool(model_field, public_field)
+        expect(proxy.map.to_maps[0]).to contain_exactly(model_field, an_instance_of(Proc))
+      end
+      it "creates the correct from_maps" do
+        proxy.map_bool(model_field, public_field)
+        expect(proxy.map.from_maps[0]).to contain_exactly(public_field, an_instance_of(Proc))
+      end
+      [true, false, nil].each do |bool|
+        it "defines a to_map that converts models' #{bool} to public's #{bool}" do
+          proxy.map_bool(model_field, public_field)
+          expect(proxy.map.to_maps[0][1].call(bool)).to eql(public_field => bool)
+        end
+      end
+      ["true", "True", "t", "T", "yes", "Yes", "Y", "y", "1"].each do |truthy_string|
+        it "defines a from_map that converts public #{truthy_string} to model true" do
+          proxy.map_bool(model_field, public_field)
+          expect(proxy.map.from_maps[0][1].call(truthy_string)).to eql(model_field => true)
+        end
+      end
+      ["false", "False", "f", "F", "no", "No", "N", "n", "0"].each do |falsey_string|
+        it "defines a from_map that converts public #{falsey_string} to model false" do
+          proxy.map_bool(model_field, public_field)
+          expect(proxy.map.from_maps[0][1].call(falsey_string)).to eql(model_field => false)
+        end
+      end
+      [nil, "nil", "null"].each do |null|
+        it "defines a from_map that converts public #{null} to model nil" do
+          proxy.map_bool(model_field, public_field)
+          expect(proxy.map.from_maps[0][1].call(null)).to eql(model_field => nil)
+        end
+      end
+    end
+
+    describe "#map_belongs_to" do
+      let(:model_field) { :user_id }
+      let(:public_field) { :user_name }
+      let(:options) { { model_class: User, sub_method: :name } }
+      let(:post) { Fabricate(:post, user: Fabricate(:user)) }
+      it "creates the correct model_fields" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.model_fields).to contain_exactly(model_field)
+      end
+      it "creates the correct public_fields" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.public_fields).to contain_exactly(public_field)
+      end
+      it "creates no simple_maps" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.simple_maps).to eql([])
+      end
+      it "creates the correct to_maps" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.to_maps[0]).to contain_exactly(model_field, an_instance_of(Proc))
+      end
+      it "creates the correct from_maps" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.from_maps[0]).to contain_exactly(public_field, an_instance_of(Proc))
+      end
+      it "defines a to_map that converts the model's parent to the public's field:value string" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.to_maps[0][1].call(post.user.id))
+          .to eql(public_field => post.user.name)
+      end
+      it "defines a from_map that converts the public's string to the model's owning model id" do
+        proxy.map_belongs_to(model_field, public_field, options)
+        expect(proxy.map.from_maps[0][1].call(post.user.name))
+          .to eql(model_field => post.user.id)
+      end
+    end
+
+    describe "#map_has_many" do
+      let(:model_field) { :posts }
+      let(:public_field) { :post_dates }
+      let(:options) { { model_class: Post, sub_method: :created_at } }
+      let(:user) { Fabricate(:user) }
+      before(:each) { Fabricate.times(2, :post, user: user) }
+      it "creates the correct model_fields" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.model_fields).to contain_exactly(model_field)
+      end
+      it "creates the correct public_fields" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.public_fields).to contain_exactly(public_field)
+      end
+      it "creates no simple_maps" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.simple_maps).to eql([])
+      end
+      it "creates the correct to_maps" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.to_maps[0]).to contain_exactly(model_field, an_instance_of(Proc))
+      end
+      it "creates the correct from_maps" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.from_maps[0]).to contain_exactly(public_field, an_instance_of(Proc))
+      end
+      it "defines a to_map that converts the model's children to the public's Array<String>" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.to_maps[0][1].call(user.posts))
+          .to eql(public_field => user.posts.pluck(:created_at))
+      end
+      it "defines a from_map that converts the public's string to the model's owning models" do
+        proxy.map_has_many(model_field, public_field, options)
+        expect(proxy.map.from_maps[0][1].call(user.posts.pluck(:created_at).to_a))
+          .to eql(model_field => user.posts.to_a)
+      end
+    end
+  end
+
+end