re_sorcery 0.1.0

data/lib/re_sorcery/fielded/expand_internal_fields.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Fielded
+    module ExpandInternalFields
+      extend Helpers
+
+      # Used internally to expand deeply nested `Fielded` structures
+      #
+      # `Hash` is intentionally *not* expanded. Create a `Fielded` class instead.
+      #
+      # Similarly, `nil` is intentionally rejected here. Use a type that more
+      # meaningfully represents an empty value instead.
+      def self.expand(obj)
+        case obj
+        when ReSorcery
+          obj.resource
+        when Fielded
+          obj.fields
+        when Linked
+          obj.links
+        when String, Numeric, Symbol, TrueClass, FalseClass
+          ok(obj)
+        when Array
+          expand_for_array(obj)
+        when URI
+          ok(obj.to_s)
+        when Hash
+          err("`Hash` cannot be safely expanded as a `field`. Use a `Fielded` class instead.")
+        when NilClass
+          err("`nil` cannot be returned as a `field`")
+        else
+          err("Cannot deeply expand fields of class #{obj.class}")
+        end
+      end
+
+      def self.expand_for_array(array)
+        array.each_with_index.inject(ok([])) do |result_array, (element, index)|
+          result_array.and_then do |ok_array|
+            expand(element)
+              .map { |good| ok_array << good }
+              .map_error { |error| "Error at index `#{index}` of Array: #{error}" }
+          end
+        end
+      end
+    end
+    private_constant :ExpandInternalFields
+  end
+end

data/lib/re_sorcery/fielded.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 're_sorcery/fielded/expand_internal_fields'
+
+module ReSorcery
+  module Fielded
+    include Helpers
+
+    module ClassMethods
+      include Decoder::BuiltinDecoders
+
+      private
+
+      # Set a field for instances of a class
+      #
+      # There is intentionally no way to make fields optionally nil. Use a type
+      # that more meaningfully represents an empty value instead, such as a
+      # `Maybe` type or discriminated unions.
+      #
+      # @param [Symbol] name
+      # @param [arg of Decoder.is] type @see `ReSorcery::Decoder.is` for details
+      # @param [Proc] pro: in the context of an instance of the class, return the value of the field
+      def field(name, type, pro = -> { send(name) })
+        ArgCheck['name', name, Symbol]
+        ArgCheck['pro', pro, Proc]
+
+        (@fields ||= {})[name] = { type: is(type), pro: pro }
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Returns the `Decoder#test`ed fields of the object, wrapped in a `Result`
+    #
+    # If all the `Decoder`s pass, this will return an `Ok`. If any of them
+    # fail, it will return an `Err` instead.
+    #
+    # @return [Result<String, Hash>]
+    def fields
+      self.class.instance_exec { @fields ||= [] }.inject(ok({})) do |result_hash, (name, field_hash)|
+        result_hash.and_then do |ok_hash|
+          field_hash[:type].test(instance_exec(&field_hash[:pro]))
+            .and_then { |tested| ExpandInternalFields.expand(tested) }
+            .map { |fielded| ok_hash.merge(name => fielded) }
+            .map_error { |error| "Error at field `#{name}` of `#{self.class}`: #{error}" }
+        end
+      end
+    end
+  end
+end

data/lib/re_sorcery/helpers.rb

@@ -0,0 +1,29 @@
+module ReSorcery
+  module Helpers
+    private
+
+    def just(value)
+      Maybe::Just.new(value)
+    end
+
+    def nothing
+      Maybe::Nothing.new
+    end
+
+    # Wrap a possibly-nil value in a `Maybe`
+    #
+    # @param value The value to wrap in a `Maybe`.
+    # @return [Maybe]
+    def nillable(value)
+      value.nil? ? nothing : just(value)
+    end
+
+    def ok(value)
+      Result::Ok.new(value)
+    end
+
+    def err(e)
+      Result::Err.new(e)
+    end
+  end
+end

data/lib/re_sorcery/linked/link_class_factory.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Linked
+    class LinkClassFactory
+      extend Decoder::BuiltinDecoders
+
+      def self.valid_rels
+        ReSorcery.configuration.fetch(
+          :link_rels,
+          %w[
+            self
+            create
+            update
+            destroy
+          ],
+        )
+      end
+
+      def self.valid_methods
+        ReSorcery.configuration.fetch(
+          :link_methods,
+          %w[
+            get
+            post
+            patch
+            put
+            delete
+          ],
+        )
+      end
+
+      URI_ABLE = is(String, URI).and do |s|
+        next true if s.is_a?(URI)
+
+        begin
+          ok(URI.parse(s))
+        rescue URI::InvalidURIError
+          err("Not a valid URI: #{s}")
+        end
+      end
+
+      def self.make_link_class
+        default_method = valid_methods.first
+        this = self
+
+        Class.new do
+          include Fielded
+
+          def initialize(args)
+            @args = args
+          end
+
+          field :rel, is(*this.valid_rels), -> { @args[:rel] }
+          field :href, URI_ABLE, -> { @args[:href] }
+          field :method, is(*this.valid_methods), -> { @args.fetch(:method, default_method) }
+          field :type, String, -> { @args.fetch(:type, 'application/json') }
+        end
+      end
+    end
+  end
+end

data/lib/re_sorcery/linked.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 're_sorcery/linked/link_class_factory'
+
+module ReSorcery
+  module Linked
+    include Helpers
+
+    module ClassMethods
+      private
+
+      # Define a set of `Link`s for a class
+      #
+      # The block is evaluated in the context of an instance of the class, so
+      # the set of `Link`s can be contextualized. For example, if the current
+      # user doesn't have permissions to edit the object, the "update" `Link`
+      # can be left out:
+      #
+      #     class MyObject
+      #       include Linked
+      #       attr_reader :id, :current_user
+      #
+      #       def initialize(id, current_user)
+      #         @id = id
+      #         @current_user = current_user
+      #       end
+      #
+      #       links do
+      #         link 'self', "/my_objects/#{id}"
+      #         link 'update', "/my_objects/#{id}", 'put' if current_user.can_update?(self)
+      #         link 'destroy', "/my_objects/#{id}", 'delete' if current_user.can_destroy?(self)
+      #       end
+      #     end
+      #
+      # The result of calling the block is not cached.
+      def links(&block)
+        @links_proc = block
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.link_class
+      @link_class ||= LinkClassFactory.make_link_class
+    end
+
+    def links
+      instance_exec(&self.class.instance_exec { @links_proc ||= -> {} })
+      created_links = (@_created_links ||= [])
+      @_created_links = [] # Clear out so `links` can run cleanly next time
+
+      created_links.each_with_index.inject(ok([])) do |result_array, (link_result, index)|
+        result_array.and_then do |ok_array|
+          link_result
+            .map { |link| ok_array << link }
+            .map_error { |error| "Error with Link at index #{index}: #{error}" }
+        end
+      end
+    end
+
+    private
+
+    # Define a `Link` for an object
+    #
+    # @see `ReSorcery::Linked::Link#initialize` for param types
+    def link(rel, href, method = 'get', type = 'application/json')
+      klass = Linked.link_class
+      (@_created_links ||= []) << klass.new(rel: rel, href: href, method: method, type: type).fields
+    end
+  end
+end

data/lib/re_sorcery/maybe/just.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Maybe
+    class Just
+      include Fielded
+
+      field :kind, :just, -> { :just }
+      field :value, Decoder.new { true }, -> { @value }
+
+      def initialize(value)
+        @value = value
+      end
+
+      def and_then(&block)
+        ArgCheck['block', block.call(@value), Just, Nothing]
+      end
+
+      def map(&block)
+        Just.new(block.call(@value))
+      end
+
+      def or_else
+        self
+      end
+
+      def get_or_else
+        @value
+      end
+
+      def assign(name, &block)
+        raise Error::NonHashAssignError, @value unless @value.is_a?(Hash)
+
+        ArgCheck['block', block.call(@value), Just, Nothing]
+          .map { |k| @value.merge(name => k) }
+      end
+
+      def ==(other)
+        other.class == Just && other.instance_eval { @value } == @value
+      end
+
+      def as_json(*)
+        {
+          kind: :just,
+          value: @value,
+        }
+      end
+    end
+  end
+end

data/lib/re_sorcery/maybe/nothing.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Maybe
+    class Nothing
+      include Fielded
+
+      field :kind, :nothing, -> { :nothing }
+
+      def and_then
+        self
+      end
+
+      def map
+        self
+      end
+
+      def or_else(&block)
+        ArgCheck['block', block.call, Just, Nothing]
+      end
+
+      def get_or_else(&block)
+        block.call
+      end
+
+      def assign(_name)
+        self
+      end
+
+      def ==(other)
+        other.class == Nothing
+      end
+
+      def as_json(*)
+        {
+          kind: :nothing,
+        }
+      end
+    end
+  end
+end

data/lib/re_sorcery/maybe.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Maybe
+  end
+end

data/lib/re_sorcery/result/err.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Result
+    class Err
+      def initialize(err)
+        @err = err
+      end
+
+      def and_then
+        self
+      end
+
+      def map
+        self
+      end
+
+      def map_error(&block)
+        Err.new(block.call(@err))
+      end
+
+      def or_else(&block)
+        ArgCheck['block', block.call(@err), Ok, Err]
+      end
+
+      def assign(_name)
+        self
+      end
+
+      def cata(ok:, err:)
+        err.call(@err)
+      end
+
+      def ==(other)
+        other.class == Err && other.instance_eval { @err } == @err
+      end
+
+      def as_json(*)
+        {
+          kind: :err,
+          value: @err,
+        }
+      end
+    end
+  end
+end

data/lib/re_sorcery/result/ok.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  module Result
+    class Ok
+      def initialize(value)
+        @value = value
+      end
+
+      def and_then(&block)
+        ArgCheck['block', block.call(@value), Ok, Err]
+      end
+
+      def map(&block)
+        Ok.new(block.call(@value))
+      end
+
+      def map_error
+        self
+      end
+
+      def or_else
+        self
+      end
+
+      def assign(name, &block)
+        raise Error::NonHashAssignError, @value unless @value.is_a?(Hash)
+
+        ArgCheck['block', block.call(@value), Ok, Err]
+          .map { |k| @value.merge(name => k) }
+      end
+
+      def cata(ok:, err:)
+        ok.call(@value)
+      end
+
+      def ==(other)
+        other.class == Ok && other.instance_eval { @value } == @value
+      end
+
+      def as_json(*)
+        {
+          kind: :ok,
+          value: @value,
+        }
+      end
+    end
+  end
+end

data/lib/re_sorcery/result.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 're_sorcery/result/ok'
+require 're_sorcery/result/err'
+
+module ReSorcery
+  module Result
+  end
+end

data/lib/re_sorcery/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ReSorcery
+  VERSION = "0.1.0"
+end

data/lib/re_sorcery.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 're_sorcery/version'
+require 're_sorcery/error'
+require 're_sorcery/arg_check'
+require 're_sorcery/maybe'
+require 're_sorcery/result'
+require 're_sorcery/helpers'
+require 're_sorcery/decoder'
+require 're_sorcery/fielded'
+require 're_sorcery/maybe/just'
+require 're_sorcery/maybe/nothing'
+require 're_sorcery/linked'
+require 're_sorcery/configuration'
+
+module ReSorcery
+  include Fielded
+  include Linked
+  include Helpers
+  extend Configuration
+
+  def self.included(base)
+    base.extend Fielded::ClassMethods
+    base.extend Linked::ClassMethods
+    @configured = "included at #{caller_locations.first}"
+  end
+
+  def resource
+    Result::Ok.new({})
+      .assign(:payload) { fields }
+      .assign(:links) { links }
+  end
+
+  def as_json(*)
+    resource.cata(
+      ok: ->(r) { r },
+      err: ->(e) { raise Error::InvalidResourceError, e },
+    )
+  end
+end

data/re_sorcery.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "re_sorcery/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "re_sorcery"
+  spec.version       = ReSorcery::VERSION
+  spec.authors       = ["Spencer Christiansen"]
+  spec.email         = ["jc.spencer92@gmail.com"]
+
+  spec.summary       = "Create resources with run-time payload type checking and link validation"
+  spec.homepage      = "https://github.com/spejamchr/re_sorcery"
+  spec.license       = "MIT"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |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.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: re_sorcery
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Spencer Christiansen
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description:
+email:
+- jc.spencer92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/re_sorcery.rb
+- lib/re_sorcery/arg_check.rb
+- lib/re_sorcery/configuration.rb
+- lib/re_sorcery/decoder.rb
+- lib/re_sorcery/decoder/builtin_decoders.rb
+- lib/re_sorcery/error.rb
+- lib/re_sorcery/fielded.rb
+- lib/re_sorcery/fielded/expand_internal_fields.rb
+- lib/re_sorcery/helpers.rb
+- lib/re_sorcery/linked.rb
+- lib/re_sorcery/linked/link_class_factory.rb
+- lib/re_sorcery/maybe.rb
+- lib/re_sorcery/maybe/just.rb
+- lib/re_sorcery/maybe/nothing.rb
+- lib/re_sorcery/result.rb
+- lib/re_sorcery/result/err.rb
+- lib/re_sorcery/result/ok.rb
+- lib/re_sorcery/version.rb
+- re_sorcery.gemspec
+homepage: https://github.com/spejamchr/re_sorcery
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/spejamchr/re_sorcery
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key:
+specification_version: 4
+summary: Create resources with run-time payload type checking and link validation
+test_files: []