upgrow 0.0.2 → 0.0.3

data/lib/upgrow/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'immutable_object'
+
+module Upgrow
+  # An Error is an all-purpose object that represents a failure in the
+  # performance of an Action. Errors are present in failure Results.
+  #
+  # Error contains a code, which is a machine-friendly unique key that
+  # represents the type of error returned. Error also contain a message, which
+  # is the human-readable text explaining the particular failure that happened.
+  # Optinally Error might also have an attribute value, which is the attribute
+  # that caused the failure, in case the error was originated from an Input.
+  class Error < ImmutableObject
+    attribute :code
+    attribute :message
+    attribute :attribute
+  end
+end

data/lib/upgrow/immutable_object.rb

@@ -1,57 +1,62 @@
 # frozen_string_literal: true
+
+require_relative 'schema'
+
 module Upgrow
   # A read-only Object. An Immutable Object is initialized with its attributes
   # and subsequent state changes are not permitted.
   class ImmutableObject
-    @attribute_names = []
+    @schema = Schema.new
 
     class << self
-      attr_reader :attribute_names
+      attr_accessor :schema
 
-      # Specify an attribute for the Immutable Object. This enables the object
-      # to be instantiated with the attribute, as well as creates an attribute
-      # reader for it.
+      # Defines an attribute in the Immutable Object Schema.
       #
       # @param name [Symbol] the name of the attribute.
       def attribute(name)
-        @attribute_names << name
-        attr_reader(name)
+        schema.attribute(name)
       end
 
       private
 
       def inherited(subclass)
         super
-        subclass.instance_variable_set(:@attribute_names, @attribute_names.dup)
+        subclass.schema = @schema.dup
       end
     end
 
+    attr_reader :attributes
+
     # Initializes a new Immutable Object with the given member values.
     #
-    # @param args [Hash<Symbol, Object>] the list of values for each attribute
-    #   of the Immutable Object.
+    # @param attributes [Hash<Symbol, Object>] the list of values for each
+    #   attribute of the Immutable Object.
     #
     # @raise [ArgumentError] if the given argument is not an attribute.
-    def initialize(**args)
-      absent_attributes = args.keys - self.class.attribute_names
+    def initialize(**attributes)
+      absent_attributes = attributes.keys - self.class.schema.attribute_names
 
       if absent_attributes.any?
         raise ArgumentError, "Unknown attribute #{absent_attributes}"
       end
 
-      args.each do |name, value|
-        instance_variable_set("@#{name}", value)
-      end
+      @attributes = self.class.schema.attribute_names.to_h do |name|
+        [name, attributes[name]]
+      end.freeze
 
       freeze
     end
 
-    # The collection of attributes and their values.
-    #
-    # @return [Hash<Symbol, Object>] the collection of attributes and their
-    #   values.
-    def attributes
-      self.class.attribute_names.to_h { |name| [name, public_send(name)] }
+    private
+
+    def method_missing(name, *args, &block)
+      super unless attributes.include?(name)
+      attributes.fetch(name)
+    end
+
+    def respond_to_missing?(name, _include_private = false)
+      attributes.include?(name) || super
     end
   end
 end

data/lib/upgrow/input.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require 'active_model'
+
+require_relative 'error'
+require_relative 'immutable_object'
+
 module Upgrow
   # Inputs are objects that represent user-entered data. They are populated with
   # information that is available for modification, such as in HTML forms or in
@@ -37,6 +42,8 @@ module Upgrow
       super(**attributes.to_hash.transform_keys(&:to_sym))
     end
 
+    undef_method :validation_context=
+
     private
 
     # Overwrites the validation context writer so the Input's state is not

data/lib/upgrow/model.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'active_record_schema'
+require_relative 'basic_model'
+
 module Upgrow
   # Models are objects that represent core entities of the app’s business logic.
   # These are usually persisted and can be fetched and created as needed. They
@@ -16,20 +19,17 @@ module Upgrow
   # Record to be completely hidden away from any other areas of the app. There
   # are no references to Records in controllers, views, and anywhere else.
   # Repositories are invoked instead, which in turn return read-only Models.
-  class Model < ImmutableObject
-    attribute :id
-    attribute :created_at
-    attribute :updated_at
+  class Model < BasicModel
+    class << self
+      private
 
-    # Initializes a new Model with the given member values.
-    #
-    # @param args [Hash<Symbol, Object>] the list of values for each attribute.
-    #
-    # @raise [KeyError] if an attribute is missing in the list of arguments.
-    def initialize(**args)
-      self.class.attribute_names.each { |key| args.fetch(key) }
+      def inherited(subclass)
+        super
 
-      super
+        subclass.schema = ActiveRecordSchema.new(
+          subclass.name + 'Record', subclass.schema
+        )
+      end
     end
   end
 end

data/lib/upgrow/model_schema.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Upgrow
+  # The default Schema type for Basic Models. This is a specialized Schema that,
+  # in addition to attributes, supports the definition of associations.
+  class ModelSchema < Schema
+    # Sets the Model Schema's initial state, with an empty Set of association
+    # names.
+    def initialize
+      super
+      @association_names = Set.new
+    end
+
+    # Define a Model association. An association is a special type of attribute
+    # that is optional upon initialization, but it raises an Association Not
+    # Loaded error in case its reader is called when the attribute has not been
+    # specified when the Model was instantiated.
+    #
+    # @param name [Symbol] the name of the association.
+    def association(name)
+      @association_names += [name]
+    end
+
+    # The list of association names for this Schema.
+    #
+    # @return [Array<Symbol>] the list of association names.
+    def association_names
+      @association_names.to_a
+    end
+  end
+end

data/lib/upgrow/repository.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'active_record_adapter'
+require_relative 'basic_repository'
+
 module Upgrow
   # Repositories are responsible for the persistence layer of the app. They
   # encapsulate Rails’ Active Record in a subset of simple methods for querying

data/lib/upgrow/result.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require_relative 'immutable_struct'
+
 module Upgrow
   # Results are special Structs that are generated dynamically to accommodate a
   # set of pre-defined members. Since different Actions might want to return
@@ -26,69 +29,29 @@ module Upgrow
       #
       # @return [Result] the new Result class with the given members.
       def new(*members)
-        super(*members, :errors)
-      end
-
-      # Returns a new Result instance populated with the given values.
-      #
-      # @param values [Hash<Symbol, Object>] the list of values for each member
-      #   provided as keyword arguments.
-      #
-      # @return [Result] the Result instance populated with the given values.
-      def success(*values)
-        new(*values)
-      end
-
-      # Returns a new Result instance populated with the given errors.
-      #
-      # @param errors [ActiveModel::Errors] the errors object to be set as the
-      #   Result errors.
-      #
-      # @return [Result] the Result instance populated with the given errors.
-      def failure(errors)
-        values = members.to_h { |member| [member, nil] }
-        new(**values.merge(errors: errors))
+        members << :errors unless members.include?(:errors)
+        super(*members)
       end
     end
 
-    # Calls the given block only when the Result is successful.
-    #
-    # This method receives a block that is called with the Result values passed
-    # to the block only when the Result itself is a success, meaning its list of
-    # errors is empty. Otherwise the block is not called.
-    #
-    # It returns self for convenience so other methods can be chained together.
+    # Returns a new Result instance populated with the given values.
     #
-    # @yield [values] gives the Result values to the block on a successful
-    #   Result.
+    # @param values [Hash<Symbol, Object>] the list of values for each member
+    #   provided as keyword arguments.
     #
-    # @return [Result] self for chaining.
-    def and_then
-      yield(**to_h.except(:errors)) if errors.none?
-      self
+    # @return [Result] the Result instance populated with the given values.
+    def initialize(**values)
+      errors = values.fetch(:errors, [])
+      super(**values.merge(errors: errors))
     end
 
-    # Calls the given block only when the Result is a failure.
-    #
-    # This method receives a block that is called with the Result errors passed
-    # to the block only when the Result itself is a failure, meaning its list of
-    # errors is not empty. Otherwise the block is not called.
-    #
-    # It returns self for convenience so other methods can be chained together.
+    # Check if the Result is successful or not. A successful Result means there
+    # are no errors present.
     #
-    # @yield [errors] gives the Result errors to the block on a failed Result.
-    #
-    # @return [Result] self for chaining.
-    def or_else
-      yield(errors) if errors.any?
-      self
-    end
-
-    private
-
-    def initialize(*args)
-      values = { errors: [] }.merge(args.first || {})
-      super(**values)
+    # @return [true] if the Result is successful.
+    # @return [false] if the Result is a failure.
+    def success?
+      errors.none?
     end
   end
 end

data/lib/upgrow/schema.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Upgrow
+  # Defines attribute names to be set in a Model class. This allows pre-defining
+  # a set of attributes to be set at once in a Model without having to declare
+  # each one by hand.
+  #
+  # A Schema is a loose concept. This is just a convenience class to be used
+  # when a more robust object is not present. In reality, any object that
+  # responds to `attribute_names` can be used as a Schema.
+  class Schema
+    # Sets the Schema's attribute names.
+    #
+    # @param attribute_names [Array<Symbol>] the attribute names to be set.
+    def initialize(*attribute_names)
+      @attribute_names = Set.new(attribute_names)
+    end
+
+    # The list of attribute names for this Schema.
+    #
+    # @return [Array<Symbol>] the list of attribute names.
+    def attribute_names
+      @attribute_names.to_a
+    end
+
+    # Defines an attribute.
+    #
+    # @param name [Symbol] the name of the attribute.
+    def attribute(name)
+      @attribute_names += [name]
+    end
+  end
+end

data/test/application_system_test_case.rb

@@ -10,4 +10,15 @@ class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
   driven_by :selenium, using: :headless_chrome do |options|
     options.add_argument('--disable-dev-shm-usage')
   end
+
+  def sign_in(email: 'existing@example.com', password: '123xyz')
+    visit(root_path)
+
+    click_link('Sign in')
+
+    fill_in('Email', with: email)
+    fill_in('Password', with: password)
+
+    click_button('Sign in')
+  end
 end

data/test/dummy/app/actions/application_action.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class ApplicationAction < Upgrow::Action
+  expose :current_user
+
+  # rubocop:disable Lint/MissingSuper
+  def initialize(user_id:)
+    @current_user = UserRepository.new.find_from_context(user_id)
+  end
+end

data/test/dummy/app/actions/articles/create_action.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Articles
+  class CreateAction < UserAction
+    expose :article
+
+    def perform(input)
+      if input.valid?
+        @article = ArticleRepository.new.create(input)
+      else
+        failure(input.errors)
+      end
+    end
+  end
+end

data/test/dummy/app/actions/articles/destroy_action.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Articles
+  class DestroyAction < UserAction
+    def perform(id)
+      ArticleRepository.new.delete(id)
+    end
+  end
+end

data/test/dummy/app/actions/articles/edit_action.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Articles
+  class EditAction < UserAction
+    expose :article
+
+    def perform(id)
+      @article = ArticleRepository.new.find_for_user(id, user: @current_user)
+      raise UnauthorizedError unless @article
+    end
+  end
+end

data/test/dummy/app/actions/articles/index_action.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Articles
+  class IndexAction < ApplicationAction
+    expose :articles
+
+    def perform
+      @articles = ArticleRepository.new.all
+    end
+  end
+end

data/test/dummy/app/actions/articles/new_action.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Articles
+  class NewAction < UserAction
+    def perform
+    end
+  end
+end

data/test/dummy/app/actions/articles/show_action.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Articles
+  class ShowAction < ApplicationAction
+    expose :article
+
+    def perform(id)
+      @article = ArticleRepository.new.find_with_comments(id)
+    end
+  end
+end

data/test/dummy/app/actions/articles/update_action.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Articles
+  class UpdateAction < UserAction
+    expose :article
+
+    def perform(id, input)
+      if input.valid?
+        @article = ArticleRepository.new.update(id, input)
+      else
+        failure(input.errors)
+      end
+    end
+  end
+end