standard-procedure-signal 0.1.1 → 0.1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c347178dc2149032ef830dc559022331c72955415a2bf989e12460a0f3114460
-  data.tar.gz: '09db2d1f954710ce4f4eb277dd950f231d93db17ba660d3d95861c7c68bb9c74'
+  metadata.gz: 62ddde59890dc0a13e2704932107e8b25bd33fabf5a48a2100a97cf7c3cbff10
+  data.tar.gz: 31233250f1bc23143b6ef40b40081cd0b31da06ced7b4a1cbc39ef5cf12d7fad
 SHA512:
-  metadata.gz: a0ad515217b9f1c5db1c179fb3b0ae9ff7320299e56d1eec1cb038ddd44f2fd31b96d60318af1c39a6a1155764633ebc03d0e2ae6471b0da86ef386fc4e78d0c
-  data.tar.gz: 604b0ed2905965347e560071cd171b817f3a75882da9ad81f518f8e86038cb676da1f2263fa07bfda8f7958567ed1a62080d7a2406949cca716392f6446beb40
+  metadata.gz: 0a7786dad91fcc094e1b98362c9644502e82a35aae9b09cc93abea6b82993e2487c6ba6be30519ae9f8581119bc359ae7b01e3231aaf56cd23d46c44ad6c5c7b
+  data.tar.gz: c14bc7e66a1f1ca678e2295c88bb9aba9503c8ebe7910606d5f85223b4edf2eca19008396cafde904f2010357c2d10a9a69f802a501ce0f1ec57753fcf3293ae

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.1.2] - 2023-09-13
+
+- Added the StandardProcedure namespace, as ::Signal is used by Ruby itself
+
 ## [0.1.1] - 2023-09-13
 
 - Added in [Signal::Attribute::Array](/lib/signal/attribute/array.rb) and [Signal::Attribute::Hash](/lib/signal/attribute/hash.rb)

data/README.md

@@ -15,18 +15,20 @@ Finally, we define an observer (our "name badge") that simply writes the display
 When we update the values stored in those various attributes, our "name badge" redraws itself when it has to but does nothing if it does not need to change.
 
 ```ruby
+include StandardProcedure::Signal
+
 # Define the basic attributes
-first_name = Signal::Attribute.text "Alice"
-last_name = Signal::Attribute.text "Aardvark"
-show_full_name = Signal::Attribute.boolean true
+first_name = attribute.text "Alice"
+last_name = attribute.text "Aardvark"
+show_full_name = attribute.boolean true
 
 # Define the composite attribute
-display_name = Signal.compute do
+display_name = compute do
   show_full_name.get ?  "#{first_name.get} #{last_name.get}" : first_name.get
 end
 
 # Define the output that the end-user will see
-display_name.observe do
+observe do
   puts "My name is #{display_name.get}"
 end
 # => My name is Alice Aardvark
@@ -39,7 +41,7 @@ show_full_name.set true
 # => My name is Alice Anteater
 
 # Perform a batch update, with no notifications until the batch is completed
-Signal.update do
+update do
   first_name.set "Anthony"
   # no output
   show_full_name.set false
@@ -80,7 +82,7 @@ This method (which, admittedly, is much harder to describe and to understand whe
 - As the dependencies are discovered at the time that the observer is being built or at the time the observer is being updated, if those dependencies change, they are automatically removed or added as required
 - As dependencies get removed automatically, we no longer maintain those hanging references, meaning memory will be cleaned up and garbage collected
 
-Looking back at the example code above, you can see that our display_name attribute has either two or three dependencies. It depends on `show_full_name` and `first_name` and it may also depend on `last_name` (if `show_full_name` is true). We then add in our "name badge", using the `Signal.observe` call. This depends on `display_name` and prints to the console every time `display_name` changes.
+Looking back at the example code above, you can see that our display_name attribute has either two or three dependencies. It depends on `show_full_name` and `first_name` and it may also depend on `last_name` (if `show_full_name` is true). We then add in our "name badge", using the `StandardProcedure::Signal.observe` call. This depends on `display_name` and prints to the console every time `display_name` changes.
 
 So, when the observer is built, it prints "My name is Alice Aardvark".
 
@@ -98,26 +100,32 @@ Finally, note that all this effectively comes for free, with no additional compl
 
 ## Usage
 
-All this is handled for you by the interaction between the [Signal](lib/signal.rb) and [Signal::Observable](lib/signal/observable.rb) modules and the [Signal::Observer](lib/signal/observer.rb) class. You never deal with Signal::Observers directly, as the Signal module will build one when you call `Signal.observe`.
+All this is handled for you by the interaction between the [StandardProcedure::Signal](lib/standard_procedure/signal.rb) and [StandardProcedure::Signal::Observable](lib/standard_procedure/signal/observable.rb) modules and the [StandardProcedure::Signal::Observer](lib/standard_procedure/signal/observer.rb) class. You never deal with StandardProcedure::Signal::Observers directly, as the StandardProcedure::Signal module will build one when you call `StandardProcedure::Signal.observe`.
 
-In addition, there is a concrete implementation of the Signal::Observable module that you can use directly. A [Signal::Attribute](lib/signal/attribute.rb) is an observable that stores any arbitrary object and notifies its observers when it is updated. There are also subclasses of Signal::Attribute that automatically perform type-conversions for you (`text, integer, float, date, time, boolean`).
+In addition, there is a concrete implementation of the StandardProcedure::Signal::Observable module that you can use directly. A [StandardProcedure::Signal::Attribute](lib/standard_procedure/signal/attribute.rb) is an observable that stores any arbitrary object and notifies its observers when it is updated. There are also subclasses of attribute that automatically perform type-conversions for you (`text, integer, float, date, time, boolean`).
 
-And `Signal.compute` allows you to build composite observables which depend on multiple other observables.
+And `StandardProcedure::Signal.compute` allows you to build composite observables which depend on multiple other observables.
 
 ```ruby
-@my_object = Signal::Attribute.new MyObject.new
-@my_text = Signal::Attribute.text "The total is: "
-@a = Signal::Attribute.integer 1
-@b = Signal::Attribute.integer 2
-@sum = Signal.compute { @a.get + @b.get }
-Signal.observe do
+include StandardProcedure::Signal
+
+@my_object = attribute.new MyObject.new
+@my_text = attribute.text "The total is: "
+@a = attribute.integer 1
+@b = attribute.integer 2
+@sum = compute { @a.get + @b.get }
+observe do
   puts "#{@my_text.get} #{@sum.get}"
 end
 ```
 
-To access the values stored in a `Signal::Attribute`, you can call `Signal::Attribute#get`. This is aliased as both `Signal::Attribute#read` and `Signal::Attribute#call` (which means you can use the short-hand `@my_attribute.()` as well).
+To access the values stored in a `attribute`, you can call `attribute#get`. This is aliased as both `attribute#read` and `attribute#call` (which means you can use the short-hand `@my_attribute.()` as well).
+
+To place a value into an attribute you call `attribute#set`, aliased as `attribute#write`.
+
+### Extensions
 
-To place a value into an attribute you call `Signal::Attribute#set`, aliased as `Signal::Attribute#write`.
+Because `StandardProcedure::Signal.observe` and `StandardProcedure::Signal::Attribute` are quite long names, you can just include the [StandardProcedure::Signal module](lib/standard_procedure/signal.rb) that you can include into your classes, to give you shortcuts.  
 
 ### Triggering updates
 
@@ -126,50 +134,56 @@ It's important to note that most observables only trigger updates when the `set`
 For example: 
 
 ```ruby
+include StandardProcedure::Signal
+
 # This will not trigger any updates
-@attribute = Signal::Attribute.string "hello"
+@attribute = attribute.string "hello"
 @attribute.get.upcase!
 
 # This will trigger updates
-@attribute = Signal::Attribute.string "hello"
+@attribute = attribute.string "hello"
 @attribute.set @attribute.get.upcase
 ```
 
 If necessary, you can manually trigger updates on an observable.  
 ```ruby
+include StandardProcedure::Signal
+
 # Manually trigger updates
-@attribute = Signal::Attribute.string "hello"
+@attribute = attribute.string "hello"
 @attribute.get.upcase!
 @attribute.update_observers 
 ```
 
-However, there are two mutable attributes that you can use - [Signal::Attribute::Array](/lib/signal/attribute/array.rb) and [Signal::Attribute::Hash](/lib/signal/attribute/hash.rb).  
+However, there are two mutable attributes that you can use - [attribute::Array](/lib/standard_procedure/signal/attribute/array.rb) and [attribute::Hash](/lib/standard_procedure/signal/attribute/hash.rb).  
 
 These are partial implementations of the ruby Array and Hash classes that are convenience wrappers when it comes to updates.  They implement Enumerable, so you can use `each`, `map` and your other favourites, plus they include a subset of the mutation methods to make it easier to manipulate the contents without repeatedly copying, changing and then setting your attributes contents.  
 
 ```ruby
+include StandardProcedure::Signal
+
 # Non-mutable array attribute 
 @array = [1, 2, 3]
-@attribute = Signal::Attribute.new @array 
+@attribute = attribute.new @array 
 @new_array = @array.dup 
 @new_array.push 4
 @attribute.set @new_array
 
 # Mutable array attribute
 @array = [1, 2, 3]
-@attribute = Signal::Attribute.array @array 
+@attribute = attribute.array @array 
 @attribute << 4
 
 # Non-mutable hash attribute 
 @hash = { key1: "value1", key2: "value2" }
-@attribute = Signal::Attribute.new @hash 
+@attribute = attribute.new @hash 
 @new_hash = @hash.dup 
 @new_hash[:key3] = "value3"
 @attribute.set @new_hash
 
 # Mutable hash attribute
 @hash = { key1: "value1", key2: "value2" }
-@attribute = Signal::Attribute.array @hash
+@attribute = attribute.array @hash
 @attribute[:key3] = "value3"
 ```
 
@@ -185,7 +199,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 Then
 
-    require "signal"
+    require "standard_procedure/signal"
 
 ## Contributing
 

data/checksums/standard-procedure-signal-0.1.2.1.gem.sha512

@@ -0,0 +1 @@
+c5a5dd921fe67d5faa376542bd566d2802d5e0389306f0e149d82a9b55b957f0270d051243e02a5fab2cca43463586408f9d1bfe707659f8135e6b20da609860

data/checksums/standard-procedure-signal-0.1.2.gem.sha512

@@ -0,0 +1 @@
+bb5307c388afc2992144df30c31e2c0b59bd555ab33f3be35557a37720deab3bf9b3a60d3ef2840f9344de3f7fd29712452ce90a0b87df6dde34b61962342d65

data/lib/standard_procedure/signal/attribute/array.rb

@@ -0,0 +1,53 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Array < Attribute
+        include Enumerable
+
+        def set(new_value)
+          new_value = if new_value.nil?
+            nil
+          elsif new_value.respond_to? :map
+            new_value.map { |i| Attribute.for i }
+          else
+            [Attribute.new(new_value)]
+          end
+          super new_value
+        end
+
+        def push item
+          @value.push item
+          update_observers
+          self
+        end
+        alias_method :<<, :push
+
+        def pop
+          item = @value.pop
+          update_observers
+          item
+        end
+
+        def shift
+          item = @value.shift
+          update_observers
+          item
+        end
+
+        def unshift item
+          @value.unshift Attribute.for(item)
+          update_observers
+          self
+        end
+
+        def last
+          @value.last
+        end
+
+        def each &block
+          @value.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/boolean.rb

@@ -0,0 +1,14 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Boolean < Attribute
+        def set(new_value)
+          new_value = !FALSEY.include?(new_value) unless new_value.nil?
+          super new_value
+        end
+
+        FALSEY = [false, 0, "0", :"0", "f", :f, "F", :F, "false", :false, "FALSE", :FALSE, "off", :off, "OFF", :OFF].freeze # standard:disable Lint/BooleanSymbol
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/date.rb

@@ -0,0 +1,22 @@
+require "date"
+require "time"
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Date < Attribute
+        def set(new_value)
+          new_value = case new_value
+          when nil then nil
+          when ::Date then new_value
+          when ::Time then ::Date.new(new_value.year, new_value.month, new_value.day)
+          when String then ::Date.parse(new_value)
+          else raise "#{new_value} not recognised"
+          end
+          super new_value
+        rescue => e
+          raise FormatError, "Cannot convert #{new_value} into a date: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/float.rb

@@ -0,0 +1,11 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Float < Attribute
+        def set(new_value)
+          super new_value&.to_f
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/format_error.rb

@@ -0,0 +1,8 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class FormatError < RuntimeError
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/hash.rb

@@ -0,0 +1,89 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Hash < Attribute
+        include Enumerable
+
+        def set(new_value)
+          new_value = if new_value.nil?
+            nil
+          elsif new_value.respond_to? :transform_values
+            new_value.transform_values { |value| Attribute.for value }
+          else
+            raise ArgumentError.new "#{new_value.inspect} is not recognised as a Hash"
+          end
+          super new_value
+        end
+
+        def each &block
+          @value.each(&block)
+        end
+
+        def keys
+          @value.keys
+        end
+
+        def include? key
+          @value.include? key
+        end
+
+        def has_key? key
+          @value.has_key? key
+        end
+
+        def has_value? value, attribute: false
+          if attribute
+            @value.has_value? value
+          else
+            @value.values.map(&:get).include? value
+          end
+        end
+
+        def values
+          @value.values
+        end
+
+        def size
+          @value.size
+        end
+        alias_method :length, :size
+
+        def any?
+          @value.any?
+        end
+
+        def empty?
+          @value.empty?
+        end
+
+        def [] key
+          @value[key]
+        end
+
+        def fetch key
+          @value.fetch key
+        end
+
+        def []= key, value
+          @value[key] = value
+          update_observers
+        end
+
+        def store key, value
+          @value.store key, value
+          update_observers
+        end
+
+        def delete key
+          @value.delete key
+          update_observers
+        end
+
+        def clear
+          @value.clear
+          update_observers
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/integer.rb

@@ -0,0 +1,13 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Integer < Attribute
+        def set(new_value)
+          super new_value&.to_i
+        rescue
+          raise FormatError, "Cannot convert #{new_value} to integer"
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/text.rb

@@ -0,0 +1,11 @@
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Text < Attribute
+        def set(new_value)
+          super new_value&.to_s
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute/time.rb

@@ -0,0 +1,22 @@
+require "date"
+require "time"
+module StandardProcedure
+  module Signal
+    class Attribute
+      class Time < Attribute
+        def set(new_value)
+          new_value = case new_value
+          when nil then nil
+          when ::Time then new_value
+          when ::Date then new_value.to_time
+          when String then ::Time.new(new_value)
+          else raise "#{new_value} not recognised"
+          end
+          super new_value
+        rescue => e
+          raise FormatError, "Cannot convert #{new_value} into a time: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/attribute.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "observable"
+module StandardProcedure
+  module Signal
+    class Attribute
+      include Observable
+      require_relative "attribute/format_error"
+      require_relative "attribute/array"
+      require_relative "attribute/boolean"
+      require_relative "attribute/date"
+      require_relative "attribute/float"
+      require_relative "attribute/hash"
+      require_relative "attribute/integer"
+      require_relative "attribute/text"
+      require_relative "attribute/time"
+
+      # Create a new, untyped, Attribute, with the given value
+      # Alternatively, you can use the class factory methods to build an attribute that automatically performs type conversions.
+      # These are Attribute.text, integer, float, boolean, date, time, array, hash
+      def initialize(value)
+        set value
+      end
+
+      class << self
+        %i[text integer float date time boolean array hash].each do |type|
+          class_name = "StandardProcedure::Signal::Attribute::#{type.to_s.capitalize}"
+          define_method type do |value|
+            const_get(class_name).new value
+          end
+        end
+
+        def for item
+          item.is_a?(StandardProcedure::Signal::Observable) ? item : Attribute.new(item)
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/manager.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module StandardProcedure
+  module Signal
+    module Manager
+      def self.update_in_progress?
+        @@update_in_progress ||= false
+      end
+
+      def self.call_stack
+        @@call_stack ||= []
+      end
+
+      def self.updated_observables
+        @@updated_observables ||= Set.new
+      end
+
+      def self.start_update
+        @@update_in_progress = true
+      end
+
+      def self.finish_update
+        @@update_in_progress = false
+        begin
+          updated_observables.each do |observable|
+            observable.update_observers
+          end
+        ensure
+          updated_observables.clear
+        end
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/observable.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module StandardProcedure
+  module Signal
+    module Observable
+      include Signal
+
+      # Get this value converted to a string
+      # @return [String]
+      def to_s
+        @value.to_s
+      end
+
+      # Get the value of this signal
+      #
+      # This method is aliased as `get` and `read` so it can be accessed in whichever way makes most sense to you
+      # The following are all equivalent:
+      #     @signal.call
+      #     @signal.get
+      #     @signal.read
+      #     @signal.()
+      #
+      # @return [Object]
+      def call
+        if (current = call_stack.last)
+          observers << current
+          current.add observers
+        end
+        @value
+      end
+      alias_method :get, :call
+      alias_method :read, :call
+
+      # Set the value of this signal and notify any observers
+      #
+      # This method is aliased as `write` it can be used in whichever way makes most sense to you
+      # The following are all equivalent:
+      #     @signal.set @new_value
+      #     @signal.write @new_value
+      #
+      # @param new_value [Object]
+      # @return [Object]
+      def set(new_value)
+        if new_value != @value
+          @value = new_value
+          update_observers
+        end
+        @value
+      end
+      alias_method :write, :set
+
+      # Notify all observers that this signal has changed
+      #
+      # If a batch update is in progress, the observers will not be notified immediately,
+      # but rather when the batch is completed.  Otherwise this triggers all observers
+      def update_observers
+        if update_in_progress?
+          updated_observables.add self
+        else
+          observers.each do |observer|
+            observer.call
+          end
+        end
+      end
+
+      private
+
+      def observers
+        @observers ||= [] # contains observers
+      end
+
+      def call_stack
+        Signal::Manager.call_stack
+      end
+
+      def update_in_progress?
+        Signal::Manager.update_in_progress?
+      end
+
+      def updated_observables
+        Signal::Manager.updated_observables
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/observer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module StandardProcedure
+  module Signal
+    class Observer
+      def initialize &block
+        @block = block
+        @observers = Set.new # contains Sets of Observers
+      end
+
+      def add set_of_observers
+        @observers.add set_of_observers
+      end
+
+      def call
+        start
+        begin
+          @block.call
+        ensure
+          finish
+        end
+      end
+
+      def start
+        @observers.each do |observer|
+          observer.delete self
+        end
+        @observers.clear
+        call_stack.push self
+      end
+
+      def finish
+        call_stack.pop
+      end
+
+      def call_stack
+        Signal::Manager.call_stack
+      end
+    end
+  end
+end

data/lib/standard_procedure/signal/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module StandardProcedure
+  module Signal
+    VERSION = "0.1.2.1"
+  end
+end

data/lib/standard_procedure/signal.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module StandardProcedure
+  module Signal
+    require_relative "signal/version"
+    require_relative "signal/manager"
+    require_relative "signal/observer"
+    require_relative "signal/observable"
+    require_relative "signal/attribute"
+
+    # Build a "computed" attribute that automatically updates based upon its dependents
+    #
+    # This compound address will be updated any time any of its constituent fields is updated
+    #
+    # include StandardProcedure::Signal
+    # @first_line = attribute.text "123 Fake Street"
+    # @second_line = attribute.text "Some place"
+    # @city = attribute.text "Springfield"
+    # @region = attribute.text "Who Knows"
+    # address = compute do
+    #   "#{first_line.get}\n#{second_line.get}\n#{city.get}\n#{region.get}"
+    # end
+    def compute(&block)
+      StandardProcedure::Signal::Attribute.new(nil).tap do |attribute|
+        observe { attribute.set block.call }
+      end
+    end
+
+    # Build an observer that gets updated whenever any of the attributes that are accessed within the block are updated
+    #
+    # This API will be posted to every time the headline or contents change
+    #
+    # include StandardProcedure::Signal
+    # @headline = attribute.text "Breaking news"
+    # @contents = attribute.text "Things have happened around the world today"
+    # api = Some::NewsBroadcaster.new(access_token)
+    # observe do
+    #   api.post headline: @headline.get, contents: @contents.get
+    # end
+    def observe(&block)
+      StandardProcedure::Signal::Observer.new(&block).call
+    end
+
+    # Batch changes to various attributes without triggering updates till the very end
+    #
+    # include StandardProcedure::Signal
+    # @expensive = attribute.text "Prada"
+    # @operation = attribute.text "Hip Replacement"
+    # update do
+    #   @expensive.set "Gucci"
+    #   @operation.set "Brain Surgery"
+    # end
+    def update(&block)
+      StandardProcedure::Signal::Manager.start_update
+      begin
+        block.call
+      ensure
+        StandardProcedure::Signal::Manager.finish_update
+      end
+    end
+
+    # Build an attribute that signals its changes to dependents
+    # See StandardProcedure::Signal::Attribute for the different types available
+    #
+    # include StandardProcedure::Signal
+    # @name = attribute.text "Alice"
+    # @age = attribute.integer 23
+    # @colours = attribute.array %w[red green blue]
+    # @object = attribute.new @some_object
+    def attribute
+      StandardProcedure::Signal::Attribute
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-signal
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2.1
 platform: ruby
 authors:
 - Rahoul Baruah
@@ -30,21 +30,23 @@ files:
 - Rakefile
 - checksums/standard-procedure-signal-0.1.0.gem.sha512
 - checksums/standard-procedure-signal-0.1.1.gem.sha512
-- lib/signal.rb
-- lib/signal/attribute.rb
-- lib/signal/attribute/array.rb
-- lib/signal/attribute/boolean.rb
-- lib/signal/attribute/date.rb
-- lib/signal/attribute/float.rb
-- lib/signal/attribute/format_error.rb
-- lib/signal/attribute/hash.rb
-- lib/signal/attribute/integer.rb
-- lib/signal/attribute/text.rb
-- lib/signal/attribute/time.rb
-- lib/signal/manager.rb
-- lib/signal/observable.rb
-- lib/signal/observer.rb
-- lib/signal/version.rb
+- checksums/standard-procedure-signal-0.1.2.1.gem.sha512
+- checksums/standard-procedure-signal-0.1.2.gem.sha512
+- lib/standard_procedure/signal.rb
+- lib/standard_procedure/signal/attribute.rb
+- lib/standard_procedure/signal/attribute/array.rb
+- lib/standard_procedure/signal/attribute/boolean.rb
+- lib/standard_procedure/signal/attribute/date.rb
+- lib/standard_procedure/signal/attribute/float.rb
+- lib/standard_procedure/signal/attribute/format_error.rb
+- lib/standard_procedure/signal/attribute/hash.rb
+- lib/standard_procedure/signal/attribute/integer.rb
+- lib/standard_procedure/signal/attribute/text.rb
+- lib/standard_procedure/signal/attribute/time.rb
+- lib/standard_procedure/signal/manager.rb
+- lib/standard_procedure/signal/observable.rb
+- lib/standard_procedure/signal/observer.rb
+- lib/standard_procedure/signal/version.rb
 - sig/standard/procedure/attribute.rbs
 homepage: https://theartandscienceofruby.com
 licenses: []

data/lib/signal/attribute/array.rb

@@ -1,51 +0,0 @@
-module Signal
-  class Attribute
-    class Array < Attribute
-      include Enumerable
-
-      def set(new_value)
-        new_value = if new_value.nil?
-          nil
-        elsif new_value.respond_to? :map
-          new_value.map { |i| Attribute.for i }
-        else
-          [Attribute.new(new_value)]
-        end
-        super new_value
-      end
-
-      def push item
-        @value.push item
-        update_observers
-        self
-      end
-      alias_method :<<, :push
-
-      def pop
-        item = @value.pop
-        update_observers
-        item
-      end
-
-      def shift
-        item = @value.shift
-        update_observers
-        item
-      end
-
-      def unshift item
-        @value.unshift Attribute.for(item)
-        update_observers
-        self
-      end
-
-      def last
-        @value.last
-      end
-
-      def each &block
-        @value.each(&block)
-      end
-    end
-  end
-end

data/lib/signal/attribute/boolean.rb

@@ -1,12 +0,0 @@
-module Signal
-  class Attribute
-    class Boolean < Attribute
-      def set(new_value)
-        new_value = !FALSEY.include?(new_value) unless new_value.nil?
-        super new_value
-      end
-
-      FALSEY = [false, 0, "0", :"0", "f", :f, "F", :F, "false", :false, "FALSE", :FALSE, "off", :off, "OFF", :OFF].freeze # standard:disable Lint/BooleanSymbol
-    end
-  end
-end

data/lib/signal/attribute/date.rb

@@ -1,20 +0,0 @@
-require "date"
-require "time"
-module Signal
-  class Attribute
-    class Date < Attribute
-      def set(new_value)
-        new_value = case new_value
-        when nil then nil
-        when ::Date then new_value
-        when ::Time then ::Date.new(new_value.year, new_value.month, new_value.day)
-        when String then ::Date.parse(new_value)
-        else raise "#{new_value} not recognised"
-        end
-        super new_value
-      rescue => e
-        raise FormatError, "Cannot convert #{new_value} into a date: #{e.message}"
-      end
-    end
-  end
-end

data/lib/signal/attribute/float.rb

@@ -1,9 +0,0 @@
-module Signal
-  class Attribute
-    class Float < Attribute
-      def set(new_value)
-        super new_value&.to_f
-      end
-    end
-  end
-end

data/lib/signal/attribute/format_error.rb

@@ -1,6 +0,0 @@
-module Signal
-  class Attribute
-    class FormatError < RuntimeError
-    end
-  end
-end

data/lib/signal/attribute/hash.rb

@@ -1,87 +0,0 @@
-module Signal
-  class Attribute
-    class Hash < Attribute
-      include Enumerable
-
-      def set(new_value)
-        new_value = if new_value.nil?
-          nil
-        elsif new_value.respond_to? :transform_values
-          new_value.transform_values { |value| Attribute.for value }
-        else
-          raise ArgumentError.new "#{new_value.inspect} is not recognised as a Hash"
-        end
-        super new_value
-      end
-
-      def each &block
-        @value.each(&block)
-      end
-
-      def keys
-        @value.keys
-      end
-
-      def include? key
-        @value.include? key
-      end
-
-      def has_key? key
-        @value.has_key? key
-      end
-
-      def has_value? value, attribute: false
-        if attribute
-          @value.has_value? value
-        else
-          @value.values.map(&:get).include? value
-        end
-      end
-
-      def values
-        @value.values
-      end
-
-      def size
-        @value.size
-      end
-      alias_method :length, :size
-
-      def any?
-        @value.any?
-      end
-
-      def empty?
-        @value.empty?
-      end
-
-      def [] key
-        @value[key]
-      end
-
-      def fetch key
-        @value.fetch key
-      end
-
-      def []= key, value
-        @value[key] = value
-        update_observers
-      end
-
-      def store key, value
-        @value.store key, value
-        update_observers
-      end
-
-      def delete key
-        @value.delete key
-        update_observers
-      end
-
-      def clear
-        @value.clear
-        update_observers
-      end
-    end
-  end
-end

data/lib/signal/attribute/integer.rb

@@ -1,11 +0,0 @@
-module Signal
-  class Attribute
-    class Integer < Attribute
-      def set(new_value)
-        super new_value&.to_i
-      rescue
-        raise FormatError, "Cannot convert #{new_value} to integer"
-      end
-    end
-  end
-end

data/lib/signal/attribute/text.rb

@@ -1,9 +0,0 @@
-module Signal
-  class Attribute
-    class Text < Attribute
-      def set(new_value)
-        super new_value&.to_s
-      end
-    end
-  end
-end

data/lib/signal/attribute/time.rb

@@ -1,20 +0,0 @@
-require "date"
-require "time"
-module Signal
-  class Attribute
-    class Time < Attribute
-      def set(new_value)
-        new_value = case new_value
-        when nil then nil
-        when ::Time then new_value
-        when ::Date then new_value.to_time
-        when String then ::Time.new(new_value)
-        else raise "#{new_value} not recognised"
-        end
-        super new_value
-      rescue => e
-        raise FormatError, "Cannot convert #{new_value} into a time: #{e.message}"
-      end
-    end
-  end
-end

data/lib/signal/attribute.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "observable"
-
-module Signal
-  class Attribute
-    include Observable
-    Dir["#{__dir__}/attribute/*.rb"].sort.each { |file| require file }
-
-    # Create a new, untyped, Attribute, with the given value
-    # Alternatively, you can use the class factory methods to build an attribute that automatically performs type conversions.
-    # These are Attribute.text, integer, float, boolean, date, time, array, hash
-    def initialize(value)
-      set value
-    end
-
-    class << self
-      %i[text integer float date time boolean array hash].each do |type|
-        class_name = "Signal::Attribute::#{type.to_s.capitalize}"
-        define_method type do |value|
-          const_get(class_name).new value
-        end
-      end
-
-      def for item
-        item.is_a?(Signal::Observable) ? item : Attribute.new(item)
-      end
-    end
-  end
-end

data/lib/signal/manager.rb

@@ -1,30 +0,0 @@
-module Signal
-  module Manager
-    def self.update_in_progress?
-      @@update_in_progress ||= false
-    end
-
-    def self.call_stack
-      @@call_stack ||= []
-    end
-
-    def self.updated_observables
-      @@updated_observables ||= Set.new
-    end
-
-    def self.start_update
-      @@update_in_progress = true
-    end
-
-    def self.finish_update
-      @@update_in_progress = false
-      begin
-        updated_observables.each do |observable|
-          observable.update_observers
-        end
-      ensure
-        updated_observables.clear
-      end
-    end
-  end
-end

data/lib/signal/observable.rb

@@ -1,87 +0,0 @@
-module Signal
-  module Observable
-    # Get this value converted to a string
-    # @return [String]
-    def to_s
-      @value.to_s
-    end
-
-    # Get the value of this signal
-    #
-    # This method is aliased as `get` and `read` so it can be accessed in whichever way makes most sense to you
-    # The following are all equivalent:
-    #     @signal.call
-    #     @signal.get
-    #     @signal.read
-    #     @signal.()
-    #
-    # @return [Object]
-    def call
-      if (current = call_stack.last)
-        observers << current
-        current.add observers
-      end
-      @value
-    end
-    alias_method :get, :call
-    alias_method :read, :call
-
-    # Set the value of this signal and notify any observers
-    #
-    # This method is aliased as `write` it can be used in whichever way makes most sense to you
-    # The following are all equivalent:
-    #     @signal.set @new_value
-    #     @signal.write @new_value
-    #
-    # @param new_value [Object]
-    # @return [Object]
-    def set(new_value)
-      if new_value != @value
-        @value = new_value
-        update_observers
-      end
-      @value
-    end
-    alias_method :write, :set
-
-    # Observe this signal
-    #
-    # The block will be called whenever this signal or its dependents is updated.
-    # The block handler does not require any parameters, simply access the signal, or any other signals and act accordingly.  If you access any dependents outside of this signal, they will be tracked and you will be notified again when they update.
-    def observe(&block)
-      Signal.observe(&block)
-    end
-
-    # Notify all observers that this signal has changed
-    #
-    # If a batch update is in progress, the observers will not be notified immediately,
-    # but rather when the batch is completed.  Otherwise this triggers all observers
-    def update_observers
-      if update_in_progress?
-        updated_observables.add self
-      else
-        observers.each do |observer|
-          observer.call
-        end
-      end
-    end
-
-    private
-
-    def observers
-      @observers ||= [] # contains observers
-    end
-
-    def call_stack
-      Signal::Manager.call_stack
-    end
-
-    def update_in_progress?
-      Signal::Manager.update_in_progress?
-    end
-
-    def updated_observables
-      Signal::Manager.updated_observables
-    end
-  end
-end

data/lib/signal/observer.rb

@@ -1,37 +0,0 @@
-module Signal
-  class Observer
-    def initialize &block
-      @block = block
-      @observers = Set.new # contains Sets of Observers
-    end
-
-    def add set_of_observers
-      @observers.add set_of_observers
-    end
-
-    def call
-      start
-      begin
-        @block.call
-      ensure
-        finish
-      end
-    end
-
-    def start
-      @observers.each do |observer|
-        observer.delete self
-      end
-      @observers.clear
-      call_stack.push self
-    end
-
-    def finish
-      call_stack.pop
-    end
-
-    def call_stack
-      Signal::Manager.call_stack
-    end
-  end
-end

data/lib/signal/version.rb

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

data/lib/signal.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Signal
-  require_relative "signal/version"
-  require_relative "signal/manager"
-  require_relative "signal/observer"
-  require_relative "signal/observable"
-  require_relative "signal/attribute"
-
-  # Build a `computed` attribute that automatically updates based upon its dependents
-  #
-  # This compound address will be updated any time any of its constituent fields is updated
-  # @first_line = Attribute.text "123 Fake Street"
-  # @second_line = Attribute.text "Some place"
-  # @city = Attribute.text "Springfield"
-  # @region = Attribute.text "Who Knows"
-  # address = Attribute.computed do
-  #   "#{first_line.get}\n#{second_line.get}\n#{city.get}\n#{region.get}"
-  # end
-  def self.compute(&block)
-    Attribute.new(nil).tap do |attribute|
-      observe { attribute.set block.call }
-    end
-  end
-
-  # Build an observer that gets updated whenever any of the attributes that are accessed within the block are updated
-  #
-  # This API will be posted to every time the headline or contents change
-  # @headline = Attribute.text "Breaking news"
-  # @contents = Attribute.text "Things have happened around the world today"
-  # api = Some::NewsBroadcaster.new(access_token)
-  # Attribute.observe do
-  #   api.post headline: @headline.get, contents: @contents.get
-  # end
-  def self.observe(&block)
-    Observer.new(&block).call
-  end
-
-  # Batch changes to various attributes without triggering updates till the very end
-  #
-  # @expensive = Attribute.text "Prada"
-  # @operation = Attribute.text "Hip Replacement"
-  # Attribute.update do
-  #   @expensive.set "Gucci"
-  #   @operation.set "Brain Surgery"
-  # end
-  def self.update(&block)
-    Signal::Manager.start_update
-    begin
-      block.call
-    ensure
-      Signal::Manager.finish_update
-    end
-  end
-end