active_remote 7.1.0 → 7.2.0

data/.gitignore

@@ -1,13 +0,0 @@
-*.gem
-*.swp
-.DS_Store
-.bundle
-.config
-.ruby-*
-.rvmrc
-.yardoc
-.idea
-Gemfile.lock
-coverage
-pkg/*
-tmp

data/Gemfile

@@ -1,4 +0,0 @@
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in active_remote.gemspec
-gemspec

data/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2012 Adam Hutchison
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/active_remote.gemspec

@@ -1,38 +0,0 @@
-$LOAD_PATH.push File.expand_path("lib", __dir__)
-require "active_remote/version"
-
-Gem::Specification.new do |s|
-  s.name = "active_remote"
-  s.version = ActiveRemote::VERSION
-  s.authors = ["Adam Hutchison"]
-  s.email = ["liveh2o@gmail.com"]
-  s.homepage = "https://github.com/liveh2o/active_remote"
-  s.summary = "Active Record for your platform"
-  s.description = "Active Remote provides Active Record-like object-relational mapping over RPC. It was written for use with Google Protocol Buffers, but could be extended to use any RPC data format."
-
-  s.files = `git ls-files`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = ">= 2.7.0"
-
-  ##
-  # Dependencies
-  #
-  s.add_dependency "activemodel", "~> 7.1.0"
-  s.add_dependency "activesupport", "~> 7.1.0"
-  s.add_dependency "protobuf", ">= 3.0"
-
-  ##
-  # Development Dependencies
-  #
-  s.add_development_dependency "benchmark-ips"
-  s.add_development_dependency "protobuf-rspec", ">= 1.1.2"
-  s.add_development_dependency "pry"
-  s.add_development_dependency "rspec-its"
-  s.add_development_dependency "rspec-pride", ">= 3.1.0"
-  s.add_development_dependency "rspec", ">= 3.3.0"
-  s.add_development_dependency "simplecov"
-  s.add_development_dependency "standard"
-  s.add_development_dependency "rake"
-end

data/bin/benchmark

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-
-require "active_remote"
-require "benchmark/ips"
-
-class Author < ::ActiveRemote::Base
-  attribute :guid, :string
-  attribute :name, :string
-  attribute :age, :integer
-  attribute :birthday, :datetime
-  attribute :writes_fiction, :boolean
-  attribute :net_sales, :float
-end
-
-ATTRIBUTES = {
-  :guid => "0c030733-3b78-4587-b94b-5e0cf26497c5",
-  :name => "Charles Dickens",
-  :age => 68,
-  :birthday => "1812-02-07 00:00:00",
-  :writes_fiction => true,
-  :net_sales => 1_000_000.0
-}
-
-::Benchmark.ips do |x|
-  x.config(:time => 20, :warmup => 10)
-  x.report("initialize") do
-    ::Author.new(ATTRIBUTES)
-  end
-
-  x.report("instantiate") do
-    ::Author.instantiate(ATTRIBUTES)
-  end
-
-  x.report("init attributes") do
-    ::Author.new(ATTRIBUTES).attributes
-  end
-
-  x.report("inst attributes") do
-    ::Author.instantiate(ATTRIBUTES).attributes
-  end
-end

data/bin/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "active_remote"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-require "pry"
-Pry.start

data/spec/lib/active_remote/association_spec.rb

@@ -1,257 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Association do
-  let(:record) { double(:record) }
-  let(:records) { [record] }
-
-  describe ".belongs_to" do
-    context "simple association" do
-      let(:author_guid) { "AUT-123" }
-      let(:user_guid) { "USR-123" }
-      let(:default_category_guid) { "CAT-123" }
-      subject { Post.new(author_guid: author_guid, user_guid: user_guid) }
-
-      it { is_expected.to respond_to(:author) }
-      it { is_expected.to respond_to(:author=) }
-
-      it "searches the associated model for a single record" do
-        expect(Author).to receive(:search).with({guid: subject.author_guid}).and_return(records)
-        expect(subject.author).to eq record
-      end
-
-      it "memoizes the result record" do
-        expect(Author).to receive(:search).once.with({guid: subject.author_guid}).and_return(records)
-        3.times { expect(subject.author).to eq record }
-      end
-
-      context "when guid is nil" do
-        subject { Post.new }
-
-        it "returns nil" do
-          expect(subject.author).to be_nil
-        end
-      end
-
-      context "when the search is empty" do
-        it "returns a nil" do
-          expect(Author).to receive(:search).with({guid: subject.author_guid}).and_return([])
-          expect(subject.author).to be_nil
-        end
-      end
-
-      context "scoped field" do
-        it { is_expected.to respond_to(:user) }
-
-        it "searches the associated model for multiple records" do
-          expect(Author).to receive(:search).with({guid: subject.author_guid, user_guid: subject.user_guid}).and_return(records)
-          expect(subject.user).to eq(record)
-        end
-
-        context "when user_guid doesnt exist on model " do
-          before { allow(subject.class).to receive_message_chain(:public_instance_methods, :include?).with(:user_guid).and_return(false) }
-
-          it "raises an error" do
-            expect { subject.user }.to raise_error(::RuntimeError, /Could not find attribute/)
-          end
-        end
-
-        context "when user_guid doesnt exist on associated model " do
-          before { allow(Author).to receive_message_chain(:public_instance_methods, :include?).with(:user_guid).and_return(false) }
-
-          it "raises an error" do
-            expect { subject.user }.to raise_error(::RuntimeError, /Could not find attribute/)
-          end
-        end
-      end
-    end
-
-    context "specific association with class name" do
-      let(:author_guid) { "AUT-456" }
-
-      subject { Post.new(author_guid: author_guid) }
-      it { is_expected.to respond_to(:coauthor) }
-
-      it "searches the associated model for a single record" do
-        expect(Author).to receive(:search).with({guid: subject.author_guid}).and_return(records)
-        expect(subject.coauthor).to eq record
-      end
-
-      it "creates a setter method" do
-        author = Author.new(guid: author_guid)
-        subject.coauthor = author
-        expect(subject.coauthor).to eq(author)
-      end
-    end
-
-    context "specific association with class name and foreign_key" do
-      let(:author_guid) { "AUT-456" }
-
-      subject { Post.new(bestseller_guid: author_guid) }
-      it { is_expected.to respond_to(:bestseller) }
-
-      it "searches the associated model for a single record" do
-        expect(Author).to receive(:search).with({guid: subject.bestseller_guid}).and_return(records)
-        expect(subject.bestseller).to eq record
-      end
-    end
-  end
-
-  describe ".has_many" do
-    let(:records) { [record, record, record] }
-    let(:guid) { "AUT-123" }
-    let(:user_guid) { "USR-123" }
-
-    subject { Author.new(guid: guid, user_guid: user_guid) }
-
-    it { is_expected.to respond_to(:posts) }
-    it { is_expected.to respond_to(:posts=) }
-
-    it "searches the associated model for all associated records" do
-      expect(Post).to receive(:search).with({author_guid: subject.guid}).and_return(records)
-      expect(subject.posts).to eq records
-    end
-
-    it "memoizes the result record" do
-      expect(Post).to receive(:search).once.with({author_guid: subject.guid}).and_return(records)
-      3.times { expect(subject.posts).to eq records }
-    end
-
-    context "when guid is nil" do
-      subject { Author.new }
-
-      it "returns []" do
-        expect(subject.posts).to eq []
-      end
-    end
-
-    context "when the search is empty" do
-      it "returns the empty set" do
-        expect(Post).to receive(:search).with({author_guid: subject.guid}).and_return([])
-        expect(subject.posts).to be_empty
-      end
-    end
-
-    context "specific association with class name" do
-      it { is_expected.to respond_to(:flagged_posts) }
-
-      it "searches the associated model for a single record" do
-        expect(Post).to receive(:search).with({author_guid: subject.guid}).and_return([])
-        expect(subject.flagged_posts).to be_empty
-      end
-    end
-
-    context "specific association with class name and foreign_key" do
-      it { is_expected.to respond_to(:bestseller_posts) }
-
-      it "searches the associated model for multiple record" do
-        expect(Post).to receive(:search).with({bestseller_guid: subject.guid}).and_return(records)
-        expect(subject.bestseller_posts).to eq(records)
-      end
-    end
-
-    context "scoped field" do
-      it { is_expected.to respond_to(:user_posts) }
-
-      it "searches the associated model for multiple records" do
-        expect(Post).to receive(:search).with({author_guid: subject.guid, user_guid: subject.user_guid}).and_return(records)
-        expect(subject.user_posts).to eq(records)
-      end
-
-      context "when user_guid doesnt exist on associated model " do
-        before { allow(Post).to receive_message_chain(:public_instance_methods, :include?).with(:user_guid).and_return(false) }
-
-        it "raises an error" do
-          expect { subject.user_posts }.to raise_error(::RuntimeError, /Could not find attribute/)
-        end
-      end
-    end
-
-    context "writer method" do
-      context "when new value is not an array" do
-        it "should raise error" do
-          expect { subject.posts = Post.new }.to raise_error(::RuntimeError, /New value must be an array/)
-        end
-      end
-    end
-  end
-
-  describe ".has_one" do
-    let(:guid) { "CAT-123" }
-    let(:user_guid) { "USR-123" }
-    let(:category_attributes) {
-      {
-        guid: guid,
-        user_guid: user_guid
-      }
-    }
-
-    subject { Category.new(category_attributes) }
-
-    it { is_expected.to respond_to(:author) }
-    it { is_expected.to respond_to(:author=) }
-
-    it "searches the associated model for all associated records" do
-      expect(Author).to receive(:search).with({category_guid: subject.guid}).and_return(records)
-      expect(subject.author).to eq record
-    end
-
-    it "memoizes the result record" do
-      expect(Author).to receive(:search).once.with({category_guid: subject.guid}).and_return(records)
-      3.times { expect(subject.author).to eq record }
-    end
-
-    context "when guid is nil" do
-      subject { Category.new }
-
-      it "returns nil" do
-        expect(subject.author).to be_nil
-      end
-    end
-
-    context "when the search is empty" do
-      it "returns a nil value" do
-        expect(Author).to receive(:search).with({category_guid: subject.guid}).and_return([])
-        expect(subject.author).to be_nil
-      end
-    end
-
-    context "specific association with class name" do
-      it { is_expected.to respond_to(:senior_author) }
-
-      it "searches the associated model for a single record" do
-        expect(Author).to receive(:search).with({category_guid: subject.guid}).and_return(records)
-        expect(subject.senior_author).to eq record
-      end
-
-      it "should create a setter method" do
-        expect(subject).to respond_to(:senior_author=)
-      end
-    end
-
-    context "specific association with class name and foreign_key" do
-      it { is_expected.to respond_to(:primary_editor) }
-
-      it "searches the associated model for a single record" do
-        expect(Author).to receive(:search).with({editor_guid: subject.guid}).and_return(records)
-        expect(subject.primary_editor).to eq record
-      end
-    end
-
-    context "scoped field" do
-      it { is_expected.to respond_to(:chief_editor) }
-
-      it "searches the associated model for multiple records" do
-        expect(Author).to receive(:search).with({chief_editor_guid: subject.guid, user_guid: subject.user_guid}).and_return(records)
-        expect(subject.chief_editor).to eq(record)
-      end
-
-      context "when user_guid doesnt exist on associated model " do
-        before { allow(Author).to receive_message_chain(:public_instance_methods, :include?).with(:user_guid).and_return(false) }
-
-        it "raises an error" do
-          expect { subject.chief_editor }.to raise_error(::RuntimeError, /Could not find attribute/)
-        end
-      end
-    end
-  end
-end

data/spec/lib/active_remote/base_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Base do
-  describe "#initialize" do
-    it "runs callbacks" do
-      expect_any_instance_of(described_class).to receive(:run_callbacks).with(:initialize)
-      described_class.new
-    end
-  end
-end

data/spec/lib/active_remote/dirty_spec.rb

@@ -1,93 +0,0 @@
-require "spec_helper"
-
-describe ActiveRemote::Dirty do
-  context "when writing attributes through the setter" do
-    subject { Post.new(name: "foo") }
-
-    before do
-      subject.changes_applied
-      subject.clear_changes_information
-    end
-
-    context "when the value changes" do
-      before { subject.name = "bar" }
-
-      its(:name_changed?) { should be_truthy }
-    end
-
-    context "when the value doesn't change" do
-      before { subject.name = "foo" }
-
-      its(:name_changed?) { should be_falsey }
-    end
-  end
-
-  context "when writing attributes directly" do
-    subject { Post.new(name: "foo") }
-
-    before do
-      subject.changes_applied
-      subject.clear_changes_information
-    end
-
-    context "when the value changes" do
-      before { subject[:name] = "bar" }
-
-      its(:name_changed?) { should be_truthy }
-    end
-
-    context "when the value doesn't change" do
-      before { subject[:name] = "foo" }
-
-      its(:name_changed?) { should be_falsey }
-    end
-  end
-
-  describe "#reload" do
-    subject { Post.new(name: "foo") }
-
-    before do
-      allow(Post).to receive(:find).and_return(Post.new(name: "foo"))
-      subject.reload
-    end
-
-    its(:changes) { should be_empty }
-  end
-
-  describe "#remote" do
-    let(:post) { Post.new(name: "foo") }
-
-    it "clears changes information" do
-      allow(post).to receive(:remote_call).and_return(::Generic::Remote::Post.new(name: "foo"))
-      expect { post.remote(:reload) }.to change { post.changed? }.to(false)
-    end
-  end
-
-  describe "#save" do
-    let!(:changes) { subject.changes }
-
-    subject { Post.new(name: "foo") }
-
-    before do
-      allow(subject).to receive(:create_or_update).and_return(true)
-      subject.save
-    end
-
-    its(:previous_changes) { should eq changes }
-    its(:changes) { should be_empty }
-  end
-
-  describe "#save!" do
-    let!(:changes) { subject.changes }
-
-    subject { Post.new(name: "foo") }
-
-    before do
-      allow(subject).to receive(:save).and_return(true)
-      subject.save!
-    end
-
-    its(:previous_changes) { should eq changes }
-    its(:changes) { should be_empty }
-  end
-end

data/spec/lib/active_remote/dsl_spec.rb

@@ -1,85 +0,0 @@
-require "spec_helper"
-
-# For testing the DSL methods
-module Another
-  class TagService < Protobuf::Rpc::Service
-  end
-end
-
-describe ActiveRemote::DSL do
-  before { reset_dsl_variables(Tag) }
-  after { Tag.service_class Generic::Remote::TagService }
-
-  describe ".attr_publishable" do
-    after { reset_publishable_attributes(Tag) }
-
-    it "appends given attributes to @publishable_attributes" do
-      Tag.attr_publishable :guid
-      Tag.attr_publishable :name
-
-      expect(Tag.publishable_attributes).to match_array([:guid, :name])
-    end
-  end
-
-  describe ".endpoints" do
-    it "has default values" do
-      expect(Tag.endpoints).to eq(
-        create: :create,
-        delete: :delete,
-        destroy: :destroy,
-        search: :search,
-        update: :update
-      )
-    end
-
-    context "given a new value for an endpoint" do
-      after { Tag.endpoints(create: :create) }
-
-      it "overwrites default values" do
-        Tag.endpoints(create: :register)
-        expect(Tag.endpoints[:create]).to eq(:register)
-      end
-    end
-  end
-
-  describe ".namespace" do
-    context "when given a value" do
-      it "sets @namespace to the value" do
-        Tag.namespace :foo
-        expect(Tag.namespace).to eq :foo
-      end
-    end
-  end
-
-  describe ".service_class" do
-    context "when nil" do
-      it "determines the service class" do
-        Tag.namespace :another
-
-        expect(Tag.service_class).to eq Another::TagService
-      end
-    end
-
-    context "when given a value" do
-      it "sets @service_class to the value" do
-        Tag.service_class Generic::Remote::TagService
-        expect(Tag.service_class).to eq Generic::Remote::TagService
-      end
-    end
-  end
-
-  describe ".service_name" do
-    context "when nil" do
-      it "determines the service name" do
-        expect(Tag.service_name).to eq :tag_service
-      end
-    end
-
-    context "when given a value" do
-      it "sets @service_name to the value" do
-        Tag.service_name :foo
-        expect(Tag.service_name).to eq :foo
-      end
-    end
-  end
-end

data/spec/lib/active_remote/errors_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe ::ActiveRemote::RemoteRecordNotSaved do
-  let(:record) { ::Tag.new }
-
-  before do
-    record.errors.add(:base, :invalid, message: "Some error one!")
-    record.errors.add(:base, :invalid, message: "Some error two!")
-  end
-
-  context "when an active remote record is used" do
-    it "uses embedded errors in message" do
-      expect { fail(::ActiveRemote::RemoteRecordNotSaved, record) }
-        .to raise_error(ActiveRemote::RemoteRecordNotSaved, "Some error one!, Some error two!")
-    end
-  end
-
-  context "when a string is used" do
-    it "uses the string in the error message" do
-      expect { fail(::ActiveRemote::RemoteRecordNotSaved, "something bad happened") }
-        .to raise_error(ActiveRemote::RemoteRecordNotSaved, "something bad happened")
-    end
-  end
-
-  context "when no message is used" do
-    it "raises the error" do
-      expect { raise(::ActiveRemote::RemoteRecordNotSaved) }
-        .to raise_error(ActiveRemote::RemoteRecordNotSaved)
-    end
-  end
-end