standard-procedure-signal 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a9695adc72f38352ff51001ae488143a3a793321e9866a9a0d80bbabe0e548a
-  data.tar.gz: 0c3e7dc3779d7486da4d1ae90a02d85c125e5215356f7278449929215815fd24
+  metadata.gz: c347178dc2149032ef830dc559022331c72955415a2bf989e12460a0f3114460
+  data.tar.gz: '09db2d1f954710ce4f4eb277dd950f231d93db17ba660d3d95861c7c68bb9c74'
 SHA512:
-  metadata.gz: a1d10d456c4c8a6a1dc4d18e9dc9886e75d0fb0eee1468a2402ddb96e0223c1b0d07975afc9b4b002250c2a2c4556bace3406b535c0b4e3e7cc3e58e45b42b30
-  data.tar.gz: fc21a499e770402d7f5879590fdd50bb3193e3edfeaade891c97c86d79cedc3b879a973703358a94d731a6d185631817fa7998e0a0fdc246a2ddc504730d6207
+  metadata.gz: a0ad515217b9f1c5db1c179fb3b0ae9ff7320299e56d1eec1cb038ddd44f2fd31b96d60318af1c39a6a1155764633ebc03d0e2ae6471b0da86ef386fc4e78d0c
+  data.tar.gz: 604b0ed2905965347e560071cd171b817f3a75882da9ad81f518f8e86038cb676da1f2263fa07bfda8f7958567ed1a62080d7a2406949cca716392f6446beb40

data/CHANGELOG.md

@@ -1,10 +1,11 @@
+## [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)
+
 ## [0.1.0] - 2023-09-08
 
 - Initial release
 
 Things to do:
 
-- Add proper rspec
-- Add in simple types - string, integer, float, date, datetime, boolean
-- Add array and hash types
 - Add compound types

data/README.md

@@ -121,48 +121,56 @@ To place a value into an attribute you call `Signal::Attribute#set`, aliased as
 
 ### Triggering updates
 
-It's important to note that observables only trigger updates when the `set` method is called with a new value. This has an important implication when it comes to manipulating or mutating values.
+It's important to note that most observables only trigger updates when the `set` method is called with a new value. This means that, in most cases, you cannot _mutate_ a value stored in an observable.  Instead, you should replace the value by calling `set`.  
 
-For example, if you put a ruby hash into an attribute, the updates will not be triggered if you add or remove keys and values in that hash.
+For example: 
 
 ```ruby
-@attribute = Signal::Attribute.new { key_1: "value_1", key_2: "value_2" }
+# This will not trigger any updates
+@attribute = Signal::Attribute.string "hello"
+@attribute.get.upcase!
 
-# These calls will *not* trigger any updates
-@attribute.get[:key_3] = "value_3"
-@attribute.get[:key_1] = "some other value"
-@attribute.get.transform_values! { |v| v.capitalize }
+# This will trigger updates
+@attribute = Signal::Attribute.string "hello"
+@attribute.set @attribute.get.upcase
 ```
 
-Instead, you need to manually trigger an update or, better yet, treat the attribute's contents as immutable and replace them.
-
-Option One: manually triggering updates
-
+If necessary, you can manually trigger updates on an observable.  
 ```ruby
-@attribute = Signal::Attribute.new { key_1: "value_1", key_2: "value_2" }
-
-@attribute.get[:key_3] = "value_3"
-@attribute.update_observers
-@attribute.get[:key_1] = "some other value"
-@attribute.update_observers
-@attribute.get.transform_values! { |v| v.capitalize }
-@attribute.update_observers
+# Manually trigger updates
+@attribute = Signal::Attribute.string "hello"
+@attribute.get.upcase!
+@attribute.update_observers 
 ```
 
-Option Two: treat the data as immutable, copy it then make changes, finally setting the attribute with the new data
-
-```ruby
-@attribute = Signal::Attribute.new { key_1: "value_1", key_2: "value_2" }
-
-data = @attribute.get.dup
-data[:key_3] = "value_3"
-@attribute.set data
+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).  
 
-data = @attribute.get.dup
-data[:key_1] = "some other value"
-@attribute.set data
+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.  
 
-@attribute.set(@attribute.get.transform_values { |v| v.capitalize })
+```ruby
+# Non-mutable array attribute 
+@array = [1, 2, 3]
+@attribute = Signal::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 << 4
+
+# Non-mutable hash attribute 
+@hash = { key1: "value1", key2: "value2" }
+@attribute = Signal::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[:key3] = "value3"
 ```
 
 ## Installation

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

@@ -0,0 +1 @@
+87fb50047e2f2b4e14e0a4b48caed00445b344719ca0ea17a8dd82ec92cd48db5ab7a1f1ea87f00da81865045b9f313260b61f34c112f8ba136999a51ae517be

data/lib/signal/attribute/array.rb

@@ -0,0 +1,51 @@
+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/hash.rb

@@ -0,0 +1,87 @@
+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.rb

@@ -15,12 +15,16 @@ module Signal
     end
 
     class << self
-      %i[text integer float date time boolean].each do |type|
+      %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/observable.rb

@@ -49,7 +49,7 @@ module 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::Manager.observe(&block)
+      Signal.observe(&block)
     end
 
     # Notify all observers that this signal has changed

data/lib/signal/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-signal
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-10 00:00:00.000000000 Z
+date: 2023-09-13 00:00:00.000000000 Z
 dependencies: []
 description: Observable attributes which adapt based upon their dependencies so we
   avoid unecessary updates
@@ -29,12 +29,15 @@ files:
 - README.md
 - 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