flow 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7cd9101a0a7a4e63855dc9355576bccb286f2f6500fce4c385cd03563650786
-  data.tar.gz: bbd6de895ef3c606e7d71df2719fe398c69eb837e7ec736825434de9356da0e1
+  metadata.gz: 46f3b0a498f717414773a7c8262c4a045a229007c4066327929c41112ced44d0
+  data.tar.gz: 354e5069d30b3fc634c54d3c0170b7b2e4f84682cd2c9f52e84e47651bd1414b
 SHA512:
-  metadata.gz: 18acdb36d7196e43166c035131d90ccbc9a73875f3bbb19b40b3a7aa8436d18510ef2b23f476a898c9bced22115d75adc92416f1bd3b34cd137fff6b6f425b4c
-  data.tar.gz: 3df8fbdb170ce58db95b1386eab961676a4e6bd684116f15da6a30bb982a952c93e0bb3e0d029f71d47a33614adc049a1986ceddb20393971e830b03c88a73de
+  metadata.gz: 5d13a497617cf8aa949ca0c77d45d27613321a9417fde96f3f3a8c4a9874954243c29e7766bf0ca94bf3908e70238920e15a9eb4fe739012cfbe74a3e6eaad78
+  data.tar.gz: cd3a356d664d7b4b334cdc436cd03f382c48d57b81e9dc3664990d502a64e39d7fd15b9c2804a88dca9a0d3066ea7d593a3b22272886d190c283ccc5fabe4061

data/README.md

@@ -1,5 +1,10 @@
 # Flow
 
+[![Gem Version](https://badge.fury.io/rb/flow.svg)](https://badge.fury.io/rb/flow)
+[![Build Status](https://semaphoreci.com/api/v1/freshly/flow/branches/master/badge.svg)](https://semaphoreci.com/freshly/flow)
+[![Maintainability](https://api.codeclimate.com/v1/badges/02131658005b10c289e0/maintainability)](https://codeclimate.com/github/Freshly/flow/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/02131658005b10c289e0/test_coverage)](https://codeclimate.com/github/Freshly/flow/test_coverage)
+
 Business logic is like nuclear fuel. 
 
 Managed properly, it's incredibly powerful and can do a lot of good.

data/lib/flow.rb

@@ -1,5 +1,17 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+require "active_support"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
+
+require "technologic"
+
 require "flow/version"
 
-module Flow
-  # Your code goes here...
-end
+require "flow/flow_base"
+require "flow/operation_base"
+require "flow/state_base"
+
+module Flow; end

data/lib/flow/flow_base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# A flow is a collection of procedurally executed operations sharing a common state.
+class FlowBase
+  class_attribute :_operations, instance_writer: false, default: []
+
+  class << self
+    def state_class
+      "#{name.chomp("Flow")}State".constantize
+    end
+
+    def trigger(*arguments)
+      new(*arguments).trigger
+    end
+
+    def operations(*operations)
+      _operations.concat(operations.flatten)
+    end
+
+    def inherited(base)
+      base._operations = _operations.dup
+      super
+    end
+  end
+
+  attr_reader :state
+
+  delegate :state_class, :_operations, to: :class
+
+  def initialize(**input)
+    @state = state_class.new(**input)
+  end
+
+  def trigger
+    _operations.each { |operation| operation.execute(state) }
+    state
+  end
+end

data/lib/flow/operation/core.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Accepts input representing the state.
+module Operation
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :state
+    end
+
+    def initialize(state)
+      @state = state
+    end
+  end
+end

data/lib/flow/operation/execute.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Execute the operation.
+module Operation
+  module Execute
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def execute(*arguments)
+        new(*arguments).execute
+      end
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+  end
+end

data/lib/flow/operation_base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "operation/core"
+require_relative "operation/execute"
+
+# Operations are service objects which are executed with a state.
+class OperationBase
+  include Technologic
+  include Operation::Core
+  include Operation::Execute
+end

data/lib/flow/state/arguments.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Arguments describe input required to define the initial state.
+module State
+  module Arguments
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_arguments, instance_writer: false, default: []
+      set_callback :initialize, :after do
+        missing = _arguments.select { |argument| public_send(argument).nil? }
+        raise ArgumentError, "Missing #{"argument".pluralize(missing.length)}: #{missing.join(", ")}" if missing.any?
+      end
+    end
+
+    class_methods do
+      def inherited(base)
+        base._arguments = _arguments.dup
+        super
+      end
+
+      protected
+
+      def argument(argument)
+        _arguments << argument
+        define_attribute argument
+      end
+    end
+  end
+end

data/lib/flow/state/attributes.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Defines the immutable structure by defining attribute accessors for the state data.
+module State
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::AttributeMethods
+
+      class_attribute :_attributes, instance_writer: false, default: []
+    end
+
+    class_methods do
+      def inherited(base)
+        base._attributes = _attributes.dup
+        super
+      end
+
+      protected
+
+      def define_attribute(attribute)
+        _attributes << attribute
+
+        attr_accessor attribute
+        define_attribute_methods attribute
+        protected "#{attribute}=".to_sym
+      end
+    end
+  end
+end

data/lib/flow/state/callbacks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# State callbacks provide an extensible mechanism for composing functionality for a state object.
+module State
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Callbacks
+      define_callbacks :initialize
+    end
+  end
+end

data/lib/flow/state/core.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Accepts input representing the arguments and input which define the initial state.
+module State
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(**input)
+      run_callbacks(:initialize) do
+        input.each { |key, value| __send__("#{key}=".to_sym, value) }
+      end
+    end
+  end
+end

data/lib/flow/state/options.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Options describe input which may be provided to define or override the initial state.
+module State
+  module Options
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_options, instance_writer: false, default: {}
+
+      set_callback :initialize, :after do
+        _options.each { |option, info| __send__("#{option}=".to_sym, info.default_value) if public_send(option).nil? }
+      end
+    end
+
+    class_methods do
+      def inherited(base)
+        dup = _options.dup
+        base._options = dup.each { |k, v| dup[k] = v.dup }
+        super
+      end
+
+      protected
+
+      def option(option, default: nil, &block)
+        _options[option] = Option.new(default: default, &block)
+        define_attribute option
+      end
+    end
+
+    class Option
+      def initialize(default:, &block)
+        @default_value = (default.nil? && block_given?) ? block : default
+      end
+
+      def default_value
+        return instance_eval(&@default_value) if @default_value.respond_to?(:call)
+
+        @default_value
+      end
+    end
+  end
+end

data/lib/flow/state/string.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Formats the state as a string.
+module State
+  module String
+    extend ActiveSupport::Concern
+
+    delegate :name, to: :class, prefix: true
+
+    def to_s
+      string_for(__method__)
+    end
+
+    def inspect
+      string_for(__method__)
+    end
+
+    protected
+
+    def stringable_attributes
+      self.class._attributes
+    end
+
+    private
+
+    def string_for(method)
+      "#<#{class_name} #{attribute_string(method)}>"
+    end
+
+    def attribute_string(method)
+      stringable_attribute_values.map { |attribute, value| "#{attribute}=#{value.public_send(method)}" }.join(" ")
+    end
+
+    def stringable_attribute_values
+      stringable_attributes.each_with_object({}) { |attribute, result| result[attribute] = public_send(attribute) }
+    end
+  end
+end

data/lib/flow/state_base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "state/callbacks"
+require_relative "state/attributes"
+require_relative "state/arguments"
+require_relative "state/options"
+require_relative "state/core"
+require_relative "state/string"
+
+# A flow state is the immutable structure of relevant data.
+class StateBase
+  include ActiveModel::Model
+  include State::Callbacks
+  include State::Attributes
+  include State::Arguments
+  include State::Options
+  include State::Core
+  include State::String
+end

data/lib/flow/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Flow
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: flow
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric Garside
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-29 00:00:00.000000000 Z
+date: 2018-12-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+- !ruby/object:Gem::Dependency
+  name: spicerack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -122,8 +164,36 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rspice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.rc1
 description: Tired of kitchen sink services, god-objects, and fat-everything? So were
-  we. Get flow.
+  we. Get in the flow.
 email:
 - eric.garside@freshly.com
 executables: []
@@ -133,6 +203,17 @@ files:
 - LICENSE.txt
 - README.md
 - lib/flow.rb
+- lib/flow/flow_base.rb
+- lib/flow/operation/core.rb
+- lib/flow/operation/execute.rb
+- lib/flow/operation_base.rb
+- lib/flow/state/arguments.rb
+- lib/flow/state/attributes.rb
+- lib/flow/state/callbacks.rb
+- lib/flow/state/core.rb
+- lib/flow/state/options.rb
+- lib/flow/state/string.rb
+- lib/flow/state_base.rb
 - lib/flow/version.rb
 homepage: http://www.freshly.com
 licenses: