carddb-rails 0.1.0

data/lib/carddb/rails/has_carddb_dataset.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+module CardDB
+  module Rails
+    module HasCardDBDataset
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_dataset_definitions, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def has_carddb_dataset(name = :carddb_dataset, dataset_key:, publisher_slug: nil, game_key: nil, client: nil,
+                               cache: nil)
+          name = name.to_sym
+          definition = {
+            dataset_key: dataset_key,
+            publisher_slug: publisher_slug,
+            game_key: game_key,
+            client: client,
+            cache: cache
+          }.freeze
+
+          self.carddb_dataset_definitions = carddb_dataset_definitions.merge(name => definition)
+
+          define_method(name) do
+            carddb_load_dataset(name)
+          end
+
+          define_method("#{name}!") do
+            public_send(name) || raise(CardDB::NotFoundError, "No CardDB dataset found for #{self.class.name}##{name}")
+          end
+
+          define_method("reload_#{name}") do
+            carddb_dataset_store.delete(name)
+            public_send(name)
+          end
+
+          define_method("#{name}_loaded?") do
+            carddb_dataset_store.key?(name)
+          end
+        end
+      end
+
+      private
+
+      def carddb_load_dataset(name)
+        return carddb_dataset_store[name] if carddb_dataset_store.key?(name)
+
+        definition = self.class.carddb_dataset_definitions.fetch(name)
+        client = carddb_dataset_resolve_client(definition[:client])
+        dataset_key = carddb_dataset_resolve_required_option(definition[:dataset_key], 'dataset_key')
+        publisher_slug = client.config.resolve_publisher(carddb_dataset_resolve_option(definition[:publisher_slug]))
+        game_key = client.config.resolve_game(carddb_dataset_resolve_option(definition[:game_key]))
+
+        raise ArgumentError, 'publisher_slug is required (no default configured)' if publisher_slug.blank?
+        raise ArgumentError, 'game_key is required (no default configured)' if game_key.blank?
+
+        record = client.datasets.get(
+          publisher_slug: publisher_slug,
+          game_key: game_key,
+          dataset_key: dataset_key,
+          cache: definition[:cache]
+        )
+
+        carddb_dataset_store[name] = record
+      end
+
+      def carddb_dataset_store
+        @carddb_dataset_store ||= {}
+      end
+
+      def carddb_dataset_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_dataset_resolve_required_option(option, name)
+        CardDB::Rails::Resolver.resolve_required_option(self, option, name)
+      end
+
+      def carddb_dataset_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/has_carddb_datasets.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+module CardDB
+  module Rails
+    module HasCardDBDatasets
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_datasets_definition, instance_accessor: false, default: nil
+      end
+
+      class_methods do
+        def has_carddb_datasets(publisher_slug: nil, game_key: nil, client: nil, cache: nil)
+          self.carddb_datasets_definition = {
+            publisher_slug: publisher_slug,
+            game_key: game_key,
+            client: client,
+            cache: cache
+          }.freeze
+        end
+      end
+
+      def carddb_datasets(purpose: nil, search: nil, first: nil, after: nil, cache: nil)
+        if purpose.nil? && search.nil? && first.nil? && after.nil?
+          return carddb_fetch_datasets(cache: cache) if cache == false
+
+          return @carddb_datasets if defined?(@carddb_datasets)
+
+          @carddb_datasets = carddb_fetch_datasets(cache: cache)
+        else
+          carddb_fetch_datasets(purpose: purpose, search: search, first: first, after: after, cache: cache)
+        end
+      end
+
+      def reload_carddb_datasets(cache: nil)
+        remove_instance_variable(:@carddb_datasets) if defined?(@carddb_datasets)
+        carddb_datasets(cache: cache)
+      end
+
+      def carddb_datasets_loaded?
+        instance_variable_defined?(:@carddb_datasets)
+      end
+
+      def carddb_dataset(dataset_key, cache: nil)
+        if cache != false && carddb_datasets_loaded? && @carddb_datasets.respond_to?(:find)
+          matching_dataset = @carddb_datasets.find { |dataset| dataset.key == dataset_key }
+          return matching_dataset if matching_dataset
+        end
+
+        definition = self.class.carddb_datasets_definition
+        raise ArgumentError, 'has_carddb_datasets must be configured before calling carddb_dataset' unless definition
+
+        client = carddb_datasets_resolve_client(definition[:client])
+        publisher_slug = client.config.resolve_publisher(carddb_datasets_resolve_option(definition[:publisher_slug]))
+        game_key = client.config.resolve_game(carddb_datasets_resolve_option(definition[:game_key]))
+
+        raise ArgumentError, 'publisher_slug is required (no default configured)' if publisher_slug.blank?
+        raise ArgumentError, 'game_key is required (no default configured)' if game_key.blank?
+
+        client.datasets.get(
+          publisher_slug: publisher_slug,
+          game_key: game_key,
+          dataset_key: dataset_key,
+          cache: cache.nil? ? definition[:cache] : cache
+        )
+      end
+
+      private
+
+      def carddb_fetch_datasets(purpose: nil, search: nil, first: nil, after: nil, cache: nil)
+        definition = self.class.carddb_datasets_definition
+        raise ArgumentError, 'has_carddb_datasets must be configured before calling carddb_datasets' unless definition
+
+        _cache = cache
+
+        client = carddb_datasets_resolve_client(definition[:client])
+        publisher_slug = client.config.resolve_publisher(carddb_datasets_resolve_option(definition[:publisher_slug]))
+        game_key = client.config.resolve_game(carddb_datasets_resolve_option(definition[:game_key]))
+
+        raise ArgumentError, 'publisher_slug is required (no default configured)' if publisher_slug.blank?
+        raise ArgumentError, 'game_key is required (no default configured)' if game_key.blank?
+
+        client.datasets.search(
+          publisher_slug: publisher_slug,
+          game_key: game_key,
+          purpose: purpose,
+          search: search,
+          first: first,
+          after: after
+        )
+      end
+
+      def carddb_datasets_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_datasets_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/has_carddb_deck.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+module CardDB
+  module Rails
+    module HasCardDBDeck
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_deck_definitions, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def has_carddb_deck(name = :carddb_deck, id: nil, external_ref: nil, client: nil, cache: nil)
+          name = name.to_sym
+          definition = {
+            id: id,
+            external_ref: external_ref,
+            client: client,
+            cache: cache
+          }.freeze
+
+          self.carddb_deck_definitions = carddb_deck_definitions.merge(name => definition)
+
+          define_method(name) do
+            carddb_load_deck(name)
+          end
+
+          define_method("#{name}!") do
+            public_send(name) || raise(CardDB::NotFoundError, "No CardDB deck found for #{self.class.name}##{name}")
+          end
+
+          define_method("reload_#{name}") do
+            carddb_deck_store.delete(name)
+            public_send(name)
+          end
+
+          define_method("#{name}_loaded?") do
+            carddb_deck_store.key?(name)
+          end
+
+          unless name == :carddb_deck
+            define_singleton_method("preload_#{name.to_s.pluralize}") do |records|
+              preload_carddb_decks(records, as: name)
+            end
+          end
+        end
+
+        def preload_carddb_decks(records, as: :carddb_deck)
+          records = Array(records).compact
+          return records if records.empty?
+
+          definition = carddb_deck_definitions.fetch(as.to_sym)
+          records.group_by { |record| record.send(:carddb_deck_batch_group_key, definition) }.each_value do |group|
+            first_record = group.first
+            client = first_record.send(:carddb_deck_resolve_client, definition[:client])
+            ids = group.filter_map { |record| record.send(:carddb_deck_resolve_option, definition[:id]) }.uniq
+            external_refs = group.filter_map { |record| record.send(:carddb_deck_resolve_option, definition[:external_ref]) }.uniq
+
+            if ids.any?
+              results = client.batch do |batch|
+                ids.each do |id|
+                  batch.decks.get(id)
+                end
+              end
+              decks_by_id = ids.zip(results).to_h
+
+              group.each do |record|
+                id = record.send(:carddb_deck_resolve_option, definition[:id])
+                record.send(:carddb_write_deck, as.to_sym, decks_by_id[id]) if id
+              end
+            elsif external_refs.any?
+              results = client.batch do |batch|
+                external_refs.each do |external_ref|
+                  batch.decks.get(external_ref: external_ref)
+                end
+              end
+              decks_by_external_ref = external_refs.zip(results).to_h
+
+              group.each do |record|
+                external_ref = record.send(:carddb_deck_resolve_option, definition[:external_ref])
+                record.send(:carddb_write_deck, as.to_sym, decks_by_external_ref[external_ref]) if external_ref
+              end
+            end
+          end
+
+          records
+        end
+      end
+
+      private
+
+      def carddb_load_deck(name)
+        return carddb_deck_store[name] if carddb_deck_store.key?(name)
+
+        definition = self.class.carddb_deck_definitions.fetch(name)
+        id = carddb_deck_resolve_option(definition[:id])
+        external_ref = carddb_deck_resolve_option(definition[:external_ref])
+        return carddb_write_deck(name, nil) if id.blank? && external_ref.blank?
+
+        client = carddb_deck_resolve_client(definition[:client])
+        deck = if id.present?
+                 client.decks.get(id, cache: definition[:cache])
+               else
+                 client.decks.get_by_external_ref(external_ref: external_ref, cache: definition[:cache])
+               end
+        carddb_write_deck(name, deck)
+      end
+
+      def carddb_write_deck(name, deck)
+        carddb_deck_store[name] = deck
+      end
+
+      def carddb_deck_store
+        @carddb_deck_store ||= {}
+      end
+
+      def carddb_deck_batch_group_key(definition)
+        client = carddb_deck_resolve_client(definition[:client])
+        [client.object_id]
+      end
+
+      def carddb_deck_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_deck_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/has_carddb_game.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+module CardDB
+  module Rails
+    module HasCardDBGame
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_game_definitions, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def has_carddb_game(name = :carddb_game, game_key:, publisher_slug: nil, client: nil, cache: nil)
+          name = name.to_sym
+          definition = {
+            game_key: game_key,
+            publisher_slug: publisher_slug,
+            client: client,
+            cache: cache
+          }.freeze
+
+          self.carddb_game_definitions = carddb_game_definitions.merge(name => definition)
+
+          define_method(name) do
+            carddb_load_game(name)
+          end
+
+          define_method("#{name}!") do
+            public_send(name) || raise(CardDB::NotFoundError, "No CardDB game found for #{self.class.name}##{name}")
+          end
+
+          define_method("reload_#{name}") do
+            carddb_game_store.delete(name)
+            public_send(name)
+          end
+
+          define_method("#{name}_loaded?") do
+            carddb_game_store.key?(name)
+          end
+        end
+      end
+
+      private
+
+      def carddb_load_game(name)
+        return carddb_game_store[name] if carddb_game_store.key?(name)
+
+        definition = self.class.carddb_game_definitions.fetch(name)
+        client = carddb_game_resolve_client(definition[:client])
+        game_key = carddb_game_resolve_required_option(definition[:game_key], 'game_key')
+        publisher_slug = client.config.resolve_publisher(carddb_game_resolve_option(definition[:publisher_slug]))
+
+        raise ArgumentError, 'publisher_slug is required (no default configured)' if publisher_slug.blank?
+
+        record = client.games.get(
+          publisher_slug: publisher_slug,
+          game_key: game_key,
+          cache: definition[:cache]
+        )
+
+        carddb_game_store[name] = record
+      end
+
+      def carddb_game_store
+        @carddb_game_store ||= {}
+      end
+
+      def carddb_game_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_game_resolve_required_option(option, name)
+        CardDB::Rails::Resolver.resolve_required_option(self, option, name)
+      end
+
+      def carddb_game_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/has_carddb_publisher.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+
+module CardDB
+  module Rails
+    module HasCardDBPublisher
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_publisher_definitions, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def has_carddb_publisher(name = :carddb_publisher, slug: nil, id: nil, client: nil, cache: nil)
+          name = name.to_sym
+          definition = {
+            slug: slug,
+            id: id,
+            client: client,
+            cache: cache
+          }.freeze
+
+          self.carddb_publisher_definitions = carddb_publisher_definitions.merge(name => definition)
+
+          define_method(name) do
+            carddb_load_publisher(name)
+          end
+
+          define_method("#{name}!") do
+            public_send(name) || raise(CardDB::NotFoundError, "No CardDB publisher found for #{self.class.name}##{name}")
+          end
+
+          define_method("reload_#{name}") do
+            carddb_publisher_store.delete(name)
+            public_send(name)
+          end
+
+          define_method("#{name}_loaded?") do
+            carddb_publisher_store.key?(name)
+          end
+        end
+      end
+
+      private
+
+      def carddb_load_publisher(name)
+        return carddb_publisher_store[name] if carddb_publisher_store.key?(name)
+
+        definition = self.class.carddb_publisher_definitions.fetch(name)
+        client = carddb_publisher_resolve_client(definition[:client])
+        slug = carddb_publisher_resolve_option(definition[:slug])
+        id = carddb_publisher_resolve_option(definition[:id])
+
+        raise ArgumentError, 'slug or id is required' if slug.blank? && id.blank?
+
+        record = client.publishers.fetch(id: id, slug: slug, cache: definition[:cache])
+        carddb_publisher_store[name] = record
+      end
+
+      def carddb_publisher_store
+        @carddb_publisher_store ||= {}
+      end
+
+      def carddb_publisher_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_publisher_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/has_carddb_record.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+module CardDB
+  module Rails
+    module HasCardDBRecord
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :carddb_record_definitions, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        def has_carddb_record(
+          name = :carddb_record,
+          dataset_key:,
+          identifier:,
+          publisher_slug: nil,
+          game_key: nil,
+          client: nil,
+          cache: nil
+        )
+          name = name.to_sym
+          definition = {
+            dataset_key: dataset_key,
+            identifier: identifier,
+            publisher_slug: publisher_slug,
+            game_key: game_key,
+            client: client,
+            cache: cache
+          }.freeze
+
+          self.carddb_record_definitions = carddb_record_definitions.merge(name => definition)
+
+          define_method(name) do
+            carddb_load_record(name)
+          end
+
+          define_method("#{name}!") do
+            public_send(name) || raise(CardDB::NotFoundError, "No CardDB record found for #{self.class.name}##{name}")
+          end
+
+          define_method("reload_#{name}") do
+            carddb_record_store.delete(name)
+            public_send(name)
+          end
+
+          define_method("#{name}_loaded?") do
+            carddb_record_store.key?(name)
+          end
+
+          unless name == :carddb_record
+            define_singleton_method("preload_#{name.to_s.pluralize}") do |records|
+              preload_carddb_records(records, as: name)
+            end
+          end
+        end
+
+        def preload_carddb_records(records, as: :carddb_record)
+          records = Array(records).compact
+          return records if records.empty?
+
+          definition = carddb_record_definitions.fetch(as.to_sym)
+          records.group_by { |record| record.send(:carddb_batch_group_key, definition) }.each_value do |group|
+            first_record = group.first
+            query_context = first_record.send(:carddb_query_context, definition)
+            identifiers = group.filter_map { |record| record.send(:carddb_resolve_option, definition[:identifier]) }.uniq
+
+            next if identifiers.empty?
+
+            results = query_context[:client].batch do |batch|
+              identifiers.each do |identifier|
+                batch.records.get(
+                  publisher_slug: query_context[:publisher_slug],
+                  game_key: query_context[:game_key],
+                  dataset_key: query_context[:dataset_key],
+                  identifier: identifier
+                )
+              end
+            end
+
+            records_by_identifier = identifiers.zip(results).to_h
+
+            group.each do |record|
+              identifier = record.send(:carddb_resolve_option, definition[:identifier])
+              record.send(:carddb_write_record, as.to_sym, records_by_identifier[identifier])
+            end
+          end
+
+          records
+        end
+      end
+
+      private
+
+      def carddb_load_record(name)
+        return carddb_record_store[name] if carddb_record_store.key?(name)
+
+        definition = self.class.carddb_record_definitions.fetch(name)
+        identifier = carddb_resolve_option(definition[:identifier])
+        return carddb_write_record(name, nil) if identifier.blank?
+
+        context = carddb_query_context(definition)
+        record = context[:client].records.get(
+          publisher_slug: context[:publisher_slug],
+          game_key: context[:game_key],
+          dataset_key: context[:dataset_key],
+          identifier: identifier,
+          cache: definition[:cache]
+        )
+
+        carddb_write_record(name, record)
+      end
+
+      def carddb_write_record(name, record)
+        carddb_record_store[name] = record
+      end
+
+      def carddb_record_store
+        @carddb_record_store ||= {}
+      end
+
+      def carddb_batch_group_key(definition)
+        context = carddb_query_context(definition)
+        [
+          context[:client].object_id,
+          context[:publisher_slug],
+          context[:game_key],
+          context[:dataset_key]
+        ]
+      end
+
+      def carddb_query_context(definition)
+        client = carddb_resolve_client(definition[:client])
+        dataset_key = carddb_resolve_required_option(definition[:dataset_key], 'dataset_key')
+        publisher_slug = client.config.resolve_publisher(carddb_resolve_option(definition[:publisher_slug]))
+        game_key = client.config.resolve_game(carddb_resolve_option(definition[:game_key]))
+
+        raise ArgumentError, 'publisher_slug is required (no default configured)' if publisher_slug.blank?
+        raise ArgumentError, 'game_key is required (no default configured)' if game_key.blank?
+
+        {
+          client: client,
+          dataset_key: dataset_key,
+          publisher_slug: publisher_slug,
+          game_key: game_key
+        }
+      end
+
+      def carddb_resolve_client(option)
+        CardDB::Rails::Resolver.resolve_client(self, option)
+      end
+
+      def carddb_resolve_required_option(option, name)
+        CardDB::Rails::Resolver.resolve_required_option(self, option, name)
+      end
+
+      def carddb_resolve_option(option)
+        CardDB::Rails::Resolver.resolve_option(self, option)
+      end
+    end
+  end
+end

data/lib/carddb/rails/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require 'active_support/ordered_options'
+
+module CardDB
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.carddb = ActiveSupport::OrderedOptions.new
+      config.carddb.credentials_key = :carddb
+      config.carddb.use_rails_cache = true
+      config.carddb.use_rails_logger = true
+
+      initializer 'carddb-rails.configure' do |app|
+        CardDB::Rails.configure do |config|
+          config.credentials_key = app.config.carddb.credentials_key
+          config.use_rails_cache = app.config.carddb.use_rails_cache
+          config.use_rails_logger = app.config.carddb.use_rails_logger
+        end
+
+        CardDB::Rails.apply_rails_configuration!(app)
+      end
+
+      initializer 'carddb-rails.controller-helpers' do
+        ActiveSupport.on_load(:action_controller_base) do
+          include CardDB::Rails::ControllerHelpers
+          include CardDB::Rails::DeckControllerHelpers
+
+          helper_method :carddb_client
+        end
+      end
+    end
+  end
+end