factory_burgers 0.0.0

data/lib/factory_burgers/factory_bot_adapter.rb

@@ -0,0 +1,44 @@
+module FactoryBurgers
+  module FactoryBotAdapter
+    module_function
+
+    def factory_bot
+      FactoryBot
+    end
+
+    def version
+      factory_boy::VERSION
+    end
+
+    def numeric_version
+      verion.split(".").map(&:to_i)
+    end
+
+    def major_version
+      numeric_versionnn.first
+    end
+
+    # TODO: support non-v6 versions
+    def load_factories
+      FactoryBot::V6.load_factories
+    end
+
+    def factories
+      FactoryBot::Internal.factories
+    end
+
+    def sequences
+      FactoryBot::Internal.sequences
+    end
+  end
+
+  module FactoryBotAdapter
+    module FactoryBot::V6
+      module_function
+
+      def load_factories
+        FactoryBurgers::FactoryBotAdapter.factory_bot.reload
+      end
+    end
+  end
+end

data/lib/factory_burgers/init.rb

@@ -0,0 +1,9 @@
+require Pathname(__dir__).join("factory_bot_adapter.rb")
+
+begin
+  require "factory_bot"
+rescue LoadError
+  raise LoadError, "Could not load factory_bot. Please make sure it is installed."
+end
+
+FactoryBurgers::FactoryBotAdapter.load_factories

data/lib/factory_burgers/introspection.rb

@@ -0,0 +1,31 @@
+module FactoryBurgers
+  module Introspection
+    module_function
+
+    def factories
+      FactoryBot::Internal.factories.sort_by(&:name)
+    end
+
+    # Return a list of factories for a model instance's associations
+    def association_factories(klass)
+      buildable_associations(klass).flat_map do |assoc|
+        factories_for_class(assoc.klass).map do |factory|
+          {
+            association: assoc,
+            factory: factory,
+          }
+        end
+      end
+    end
+
+    def factories_for_class(klass)
+      factories.select do |factory|
+        factory.build_class.ancestors.include?(klass)
+      end
+    end
+
+    def buildable_associations(klass)
+      klass.reflect_on_all_associations.reject { |assoc| assoc.is_a?(ActiveRecord::Reflection::ThroughReflection) }
+    end
+  end
+end

data/lib/factory_burgers/middleware/build.rb

@@ -0,0 +1,62 @@
+require "logger"
+require "json"
+
+module FactoryBurgers
+  module Middleware
+    # TODO: extract controller methods into controller-like classes
+    class Build
+      def call(env)
+        params = paramters(env)
+        factory = params.fetch("factory")
+        traits = params["traits"]&.keys
+        attributes = attribute_overrides(params)
+        owner = get_resource_owner(params)
+        resource = FactoryBurgers::Builder.new.build(factory, traits, attributes, owner)
+        object_data = FactoryBurgers::Models::FactoryOutput.new(resource).data
+        response_data = {ok: true, data: object_data}
+        return [200, {"Content-Type" => "application/json"}, [JSON.dump(response_data)]]
+      rescue ActiveRecord::RecordInvalid => err
+        log_error(err)
+        return [422, {"Content-Type" => "application/json"}, [JSON.dump({ok: false, error: err.message})]]
+      rescue StandardError => err
+        log_error(err)
+        return [500, {"Content-Type" => "application/json"}, [JSON.dump({ok: false, error: err.message})]]
+      end
+
+      def request(env)
+        Rack::Request.new(env)
+      end
+
+      def paramters(env)
+        request(env).params
+      end
+
+      def attribute_overrides(params)
+        attribute_items = params["attributes"] || []
+        attribute_items = attribute_items.reject{ |attr| !attr["name"].present? }
+        return attribute_items.map { |attr| [attr["name"], attr["value"]] }.to_h
+      end
+
+      # TODO: make params explicit
+      def get_resource_owner(params)
+        return nil if params[:owner_type].blank? || params[:owner_id].blank? || params[:owner_association].blank?
+
+        valid_owner_types = ActiveRecord::Base.descendants.map(&:name)
+        raise "Danger, will Robinson! #{params[:owner_type]} is an impostor!" if !valid_owner_types.include?(params[:owner_type])
+
+        klass = params[:owner_type].constantize
+        raise "Danger, will Robinson! #{params[:owner_association]} is an impostor!" if !klass.reflections.include?(params[:owner_association])
+
+        return params[:owner_type].constantize.find(params[:owner_id])
+      end
+
+      def log_error(error)
+        logger.error("#{error.class}: #{error.message}\n" + error.backtrace&.join("\n").to_s)
+      end
+
+      def logger
+        @logger ||= Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/factory_burgers/middleware/data.rb

@@ -0,0 +1,17 @@
+require "json"
+
+module FactoryBurgers
+  module Middleware
+    class Data
+      def call(env)
+        factories = FactoryBot.factories.sort_by(&:name)
+        factory_data = factories.map { |factory| factory_data(factory) }
+        return [200, {"Content-Type" => "application/json"}, [JSON.dump(factory_data)]]
+      end
+
+      def factory_data(factory)
+        FactoryBurgers::Models::Factory.new(factory).to_h
+      end
+    end
+  end
+end

data/lib/factory_burgers/middleware/static.rb

@@ -0,0 +1,35 @@
+module FactoryBurgers
+  module Middleware
+    class Static
+      def call(env)
+        return slashpath_redirect(env["REQUEST_PATH"]) if slashpath_redirect?(env)
+
+        rack_static.call(env)
+      end
+
+      def slashpath_redirect?(env)
+        env["REQUEST_PATH"] == env["SCRIPT_NAME"] && env["REQUEST_PATH"][-1] != "/"
+      end
+
+      def slashpath_redirect(path)
+        return [
+          302,
+          {'Location' => path + "/", 'Content-Type' => 'text/html', 'Content-Length' => '0'},
+          [],
+        ]
+      end
+
+      def rack_static
+        Rack::Static.new(nil, static_options)
+      end
+
+      def static_options
+        {urls: [""], root: asset_path, index: 'index.html'}
+      end
+
+      def asset_path
+        @asset_path ||= FactoryBurgers.root.join("assets/")
+      end
+    end
+  end
+end

data/lib/factory_burgers/models/factory.rb

@@ -0,0 +1,98 @@
+require "json"
+
+module FactoryBurgers
+  module Models
+    # TODO: support transient attributes (f.definition.attributes ...?)
+    # TODO: support associations
+    class Factory
+      attr_reader :factory
+
+      def initialize(factory)
+        @factory = factory
+      end
+
+      def to_h
+        {
+          name: name,
+          class_name: class_name,
+          traits: traits.map(&:to_h),
+          attributes: attributes.map(&:to_h),
+        }
+      end
+
+      def to_json(*opts, &blk)
+        to_h.to_json(*opts, &blk)
+      end
+
+      def name
+        factory.name.to_s
+      end
+
+      def class_name
+        build_class.base_class.name
+      end
+
+      def traits
+        defined_traits.map { |trait| Trait.new(trait) }
+      end
+
+      def attributes
+        settable_columns.map { |col| Attribute.new(col) }
+      end
+
+      private
+
+      def build_class
+        factory.build_class
+      end
+
+      def settable_columns
+        factory.build_class.columns.reject { |col| col.name == build_class.primary_key }
+      end
+
+      def defined_traits
+        factory.definition.defined_traits
+      end
+    end
+
+    class Attribute
+      attr_reader :column
+
+      def initialize(column)
+        @column = column
+      end
+
+      def to_h
+        {name: name}
+      end
+
+      def to_json(*opts, &blk)
+        to_h.to_json(*opts, &blk)
+      end
+
+      def name
+        column.name
+      end
+    end
+
+    class Trait
+      attr_reader :trait
+
+      def initialize(trait)
+        @trait = trait
+      end
+
+      def to_h
+        {name: name}
+      end
+
+      def to_json(*opts, &blk)
+        to_h.to_json(*opts, &blk)
+      end
+
+      def name
+        trait.name
+      end
+    end
+  end
+end

data/lib/factory_burgers/models/factory_output.rb

@@ -0,0 +1,38 @@
+module FactoryBurgers
+  module Models
+    class FactoryOutput
+      attr_reader :object, :presenter
+
+      # `object` is whatever the output of `Factory#create` was
+      def initialize(object)
+        @object = object
+        @presenter = FactoryBurgers::Presenters.presenter_for(object)
+      end
+
+      def data
+        # TODO: Sorting by name is a UI concern; move it there.
+        sorted_assocs = association_factories.sort_by { |item| item[:association].name }
+        # TODO: group type, attributes, and link into `object`, move keys into presenter
+        return {
+          type: presenter.type,
+          attributes: presenter.attributes,
+          link: presenter.link_path,
+          association_factories: sorted_assocs.map { |item| association_factory_data(item) },
+        }
+      end
+
+      private
+
+      def association_factories
+        FactoryBurgers::Introspection.association_factories(object.class)
+      end
+
+      def association_factory_data(assoc_factory)
+        {
+          association_name: assoc_factory[:association].name.to_s,
+          factory_name: assoc_factory[:factory].name.to_s,
+        }
+      end
+    end
+  end
+end

data/lib/factory_burgers/presenter_builder.rb

@@ -0,0 +1,41 @@
+module FactoryBurgers
+  class PresenterBuilder < BasicObject
+    def initialize(klass)
+      @presenter = ::Class.new(::FactoryBurgers::Presenters::Base)
+      @klass = klass
+    end
+
+    def build(&blk)
+      instance_eval(&blk)
+      return @presenter
+    end
+
+    def presents(name)
+      @presetner.presents(name)
+    end
+
+    def type(&blk)
+      @presenter.define_method(:type) do
+        blk.call(object)
+      end
+    end
+
+    def type(&blk)
+      @presenter.define_method(:type) do
+        blk.call(object)
+      end
+    end
+
+    def attributes(&blk)
+      @presenter.define_method(:attributes) do
+        blk.call(object)
+      end
+    end
+
+    def link_path(&blk)
+      @presenter.define_method(:link_path) do
+        blk.call(object)
+      end
+    end
+  end
+end

data/lib/factory_burgers/presenters.rb

@@ -0,0 +1,46 @@
+module FactoryBurgers
+  module Presenters
+    @presenters = {}
+
+    module_function
+
+    def present(klass, with: nil, &blk)
+      raise ArgumentError, "Provide `with` or block, but not both" if with && blk
+
+      presenter = with || build_presenter(klass, &blk)
+      @presenters[klass.to_s] = presenter
+    end
+
+    def purge!
+      @links = {}
+      @presenters = {}
+    end
+
+    def presenter_for(object)
+      presenter_class_for(object).new(object)
+    end
+
+    def presenter_class_for(object)
+      matching_class = object.class.ancestors.map(&:name).find do |class_name|
+        @presenters.key?(class_name)
+      end
+
+      return matching_class ? @presenters[matching_class] : FactoryBurgers::Presenters::Base
+    end
+
+    # TODO use this from FactoryOutput
+    def data_for(object)
+      presenter = presenter_for(object) or return nil
+      {
+        type: presenter.type,
+        attribuets: presenter.attributes,
+        link: presenter.link_path,
+      }
+    end
+
+    # block provided to `present`; build a presenter class
+    def build_presenter(klass, &blk)
+      PresenterBuilder.new(klass).build(&blk)
+    end
+  end
+end

data/lib/factory_burgers/presenters/base.rb

@@ -0,0 +1,29 @@
+module FactoryBurgers
+  module Presenters
+    class Base
+      class << self
+        def presents(name)
+          define_method(name) { object }
+        end
+      end
+
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def type
+        object.class.name
+      end
+
+      def attributes
+        object.attributes.slice("id", "name")
+      end
+
+      def link_path
+        nil
+      end
+    end
+  end
+end