isomorfeus-data 1.0.0.zeta5 → 1.0.0.zeta6

data/lib/isomorfeus_data/lucid_data/array/mixin.rb

@@ -0,0 +1,570 @@
+module LucidData
+  module Array
+    module Mixin
+      def self.included(base)
+        base.include(Enumerable)
+        base.extend(LucidPropDeclaration::Mixin)
+        base.extend(Isomorfeus::Data::GenericClassApi)
+        base.include(Isomorfeus::Data::GenericInstanceApi)
+
+        base.instance_exec do
+          def elements(validate_hash = {})
+            @element_conditions = validate_hash
+          end
+          alias element elements
+
+          def element_conditions
+            @element_conditions
+          end
+
+          def valid_element?(element)
+            return true unless @element_conditions
+            Isomorfeus::Data::ElementValidator.new(self.name, element, @element_conditions).validate!
+          rescue
+            false
+          end
+        end
+
+        def composition
+          @_composition
+        end
+
+        def composition=(c)
+          @_composition = c
+        end
+
+        def changed!
+          @_composition.changed! if @_composition
+          @_changed = true
+        end
+
+        def _validate_element(el)
+          Isomorfeus::Data::ElementValidator.new(@class_name, el, @_el_con).validate!
+        end
+
+        if RUBY_ENGINE == 'opal'
+          def initialize(key:, revision: nil, elements: nil, composition: nil)
+            @key = key.to_s
+            @class_name = self.class.name
+            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+            @_store_path = [:data_state, @class_name, @key, :elements]
+            @_revision = revision ? revision : Redux.fetch_by_path(:data_state, @class_name, @key, :revision)
+            @_changed_array = nil
+            @_composition = composition
+            @_changed = false
+            @_el_con = self.class.element_conditions
+            @_validate_elements = @_el_con ? true : false
+            if @_validate_elements && elements
+              elements.each { |e| _validate_element(e) }
+            end
+            raw_array = Redux.fetch_by_path(*@_store_path)
+            if `raw_array === null`
+              @_changed_array = elements ? elements : []
+            elsif raw_array && !elements.nil?
+              @_changed_array = elements
+            end
+          end
+
+          def _load_from_store!
+            @_changed = false
+            @_changed_array = nil
+          end
+
+          def _get_array
+            return @_changed_array if @_changed_array
+            Redux.fetch_by_path(*@_store_path)
+          end
+
+          def changed?
+            @_changed || !!@_changed_array
+          end
+
+          def each(&block)
+            _get_array.each(&block)
+          end
+
+          def to_transport
+            hash = { 'elements' => _get_array }
+            hash.merge!('revision' => revision) if revision
+            { @class_name => { @key =>  hash }}
+          end
+
+          # Array methods
+          def method_missing(method_name, *args, &block)
+            raw_array = _get_array
+            raw_array.send(method_name, *args, &block)
+          end
+
+          def <<(element)
+            _validate_element(element) if @_validate_elements
+            raw_array = _get_array
+            result = raw_array << element
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def [](idx)
+            _get_array[idx]
+          end
+
+          def []=(idx, element)
+            _validate_element(element) if @_validate_elements
+            raw_array = _get_array
+            raw_array[idx] = element
+            @_changed_array = raw_array
+            changed!
+            element
+          end
+
+          def clear
+            @_changed_array = []
+            changed!
+            self
+          end
+
+          def collect!(&block)
+            raw_array = _get_array
+            raw_array.collect!(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def compact!
+            raw_array = _get_array
+            result = raw_array.compact!
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def concat(*args)
+            raw_array = _get_array
+            raw_array.concat(*args)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def delete(element, &block)
+            raw_array = _get_array
+            result = raw_array.delete(element, &block)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def delete_at(idx)
+            raw_array = _get_array
+            result = raw_array.delete_at(idx)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def delete_if(&block)
+            raw_array = _get_array
+            raw_array.delete_if(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def fill(*args, &block)
+            raw_array = _get_array
+            raw_array.fill(*args, &block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def filter!(&block)
+            raw_array = _get_array
+            result = raw_array.filter!(&block)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def flatten!(level = nil)
+            raw_array = _get_array
+            result = raw_array.flatten!(level)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def insert(*args)
+            raw_array = _get_array
+            raw_array.insert(*args)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def keep_if(&block)
+            raw_array = _get_array
+            raw_array.keep_if(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def map!(&block)
+            raw_array = _get_array
+            raw_array.map!(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def pop(n = nil)
+            raw_array = _get_array
+            result = raw_array.pop(n)
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def push(*elements)
+            if @_validate_elements
+              elements.each { |element| _validate_element(element) }
+            end
+            raw_array = _get_array
+            raw_array.push(*elements)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+          alias append push
+
+          def reject!(&block)
+            raw_array = _get_array
+            result = raw_array.reject!(&block)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def reverse!
+            raw_array = _get_array
+            raw_array.reverse!
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def rotate!(count = 1)
+            raw_array = _get_array
+            raw_array.rotate!(count)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def select!(&block)
+            raw_array = _get_array
+            result = raw_array.select!(&block)
+            return nil if result.nil?
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def shift(n = nil)
+            raw_array = _get_array
+            result = raw_array.shift(n)
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def shuffle!(*args)
+            raw_array = _get_array
+            raw_array.shuffle!(*args)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def slice!(*args)
+            raw_array = _get_array
+            result = raw_array.slice!(*args)
+            @_changed_array = raw_array
+            changed!
+            result
+          end
+
+          def sort!(&block)
+            raw_array = _get_array
+            raw_array.sort!(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def sort_by!(&block)
+            raw_array = _get_array
+            raw_array.sort_by!(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def uniq!(&block)
+            raw_array = _get_array
+            raw_array.uniq!(&block)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+
+          def unshift(*args)
+            raw_array = _get_array
+            raw_array.unshift(*args)
+            @_changed_array = raw_array
+            changed!
+            self
+          end
+          alias prepend unshift
+        else # RUBY_ENGINE
+          unless base == LucidData::Array::Base
+            Isomorfeus.add_valid_data_class(base)
+            base.prop :pub_sub_client, default: nil
+            base.prop :current_user, default: Anonymous.new
+          end
+
+          base.instance_exec do
+            def load(key:, pub_sub_client: nil, current_user: nil)
+              data = instance_exec(key: key, &@_load_block)
+              revision = nil
+              revision = data.delete(:revision) if data.key?(:revision)
+              elements = data.delete(:elements)
+              self.new(key: key, revision: revision, elements: elements)
+            end
+          end
+
+          def initialize(key:, revision: nil, elements: nil, composition: nil)
+            @key = key.to_s
+            @class_name = self.class.name
+            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+            @_revision = revision
+            @_changed = false
+            @_composition = composition
+            @_el_con = self.class.element_conditions
+            @_validate_elements = @_el_con ? true : false
+            elements = [] unless elements
+            if @_validate_elements
+              elements.each { |e| _validate_element(e) }
+            end
+            @_raw_array = elements
+          end
+
+          def changed?
+            @_changed
+          end
+
+          def each(&block)
+            @_raw_array.each(&block)
+          end
+
+          def to_transport
+            hash = { 'elements' => @_raw_array }
+            hash.merge!('revision' => revision) if revision
+            { @class_name => { @key => hash }}
+          end
+
+          # Array methods
+          def method_missing(method_name, *args, &block)
+            @_raw_array.send(method_name, *args, &block)
+          end
+
+          def <<(element)
+            _validate_element(element) if @_validate_elements
+            changed!
+            @_raw_array << element
+          end
+
+          def []=(idx, element)
+            _validate_element(element) if @_validate_elements
+            changed!
+            @_raw_array[idx] = element
+          end
+
+          def clear
+            @_raw_array = []
+            self
+          end
+
+          def collect!(&block)
+            changed!
+            @_raw_array.collect!(&block)
+            self
+          end
+
+          def compact!
+            result = @_raw_array.compact!
+            return nil if result.nil?
+            changed!
+            self
+          end
+
+          def concat(*args)
+            changed!
+            @_raw_array.concat(*args)
+            self
+          end
+
+          def delete(element, &block)
+            result = @_raw_array.delete(element, &block)
+            changed!
+            result
+          end
+
+          def delete_at(idx)
+            result = @_raw_array.delete_at(idx)
+            return nil if result.nil?
+            changed!
+            result
+          end
+
+          def delete_if(&block)
+            @_raw_array.delete_if(&block)
+            changed!
+            self
+          end
+
+          def fill(*args, &block)
+            @_raw_array.fill(*args, &block)
+            changed!
+            self
+          end
+
+          def filter!(&block)
+            result = @_raw_array.filter!(&block)
+            return nil if result.nil?
+            changed!
+            self
+          end
+
+          def flatten!(level = nil)
+            result = @_raw_array.flatten!(level)
+            return nil if result.nil?
+            changed!
+            self
+          end
+
+          def insert(*args)
+            @_raw_array.insert(*args)
+            changed!
+            self
+          end
+
+          def keep_if(&block)
+            @_raw_array.keep_if(&block)
+            changed!
+            self
+          end
+
+          def map!(&block)
+            @_raw_array.map!(&block)
+            changed!
+            self
+          end
+
+          def pop(n = nil)
+            result = @_raw_array.pop(n)
+            changed!
+            result
+          end
+
+          def push(*elements)
+            if @_validate_elements
+              elements.each { |element| _validate_element(element) }
+            end
+            @_raw_array.push(*elements)
+            changed!
+            self
+          end
+          alias append push
+
+          def reject!(&block)
+            result = @_raw_array.reject!(&block)
+            return nil if result.nil?
+            changed!
+            self
+          end
+
+          def reverse!
+            @_raw_array.reverse!
+            changed!
+            self
+          end
+
+          def rotate!(count = 1)
+            @_raw_array.rotate!(count)
+            changed!
+            self
+          end
+
+          def select!(&block)
+            result = @_raw_array.select!(&block)
+            return nil if result.nil?
+            changed!
+            self
+          end
+
+          def shift(n = nil)
+            result = @_raw_array.shift(n)
+            changed!
+            result
+          end
+
+          def shuffle!(*args)
+            @_raw_array.shuffle!(*args)
+            changed!
+            self
+          end
+
+          def slice!(*argsk)
+            result = @_raw_array.slice!(*args)
+            changed!
+            result
+          end
+
+          def sort!(&block)
+            @_raw_array.sort!(&block)
+            changed!
+            self
+          end
+
+          def sort_by!(&block)
+            @_raw_array.sort_by!(&block)
+            changed!
+            self
+          end
+
+          def uniq!(&block)
+            @_raw_array.uniq!(&block)
+            changed!
+            self
+          end
+
+          def unshift(*args)
+            @_raw_array.unshift(*args)
+            changed!
+            self
+          end
+          alias prepend unshift
+        end  # RUBY_ENGINE
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_data/collection/base.rb

@@ -0,0 +1,15 @@
+module LucidData
+  module Collection
+    class Base
+      include LucidData::Collection::Mixin
+
+      if RUBY_ENGINE != 'opal'
+        def self.inherited(base)
+          Isomorfeus.add_valid_data_class(base)
+          base.prop :pub_sub_client, default: nil
+          base.prop :current_user, default: Anonymous.new
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_data/collection/finders.rb

@@ -0,0 +1,83 @@
+module LucidData
+  module Collection
+    module Finders
+      def find(attribute_hash = nil, &block)
+        if block_given?
+          nodes.each do |node|
+            return node if block.call(node)
+          end
+        else
+          node_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          nodes.each do |node|
+            if node_class
+              next unless node.class == node_class
+            end
+            if is_a_module
+              next unless node.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (node[k] == v)
+              break unless found
+            end
+            return node if found
+          end
+        end
+        nil
+      end
+
+      def find_all(attribute_hash = nil, &block)
+        found_nodes = []
+        if block_given?
+          nodes.each do |node|
+            found_nodes << node if block.call(node)
+          end
+        else
+          node_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          nodes.each do |node|
+            if node_class
+              next unless node.class == node_class
+            end
+            if is_a_module
+              next unless node.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (node[k] == v)
+              break unless found
+            end
+            found_nodes << node if found
+          end
+        end
+        found_nodes
+      end
+
+      def find_by_key(node_key)
+        nodes.each do |node|
+          return node if node.key == node_key
+        end
+        nil
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def find_by_sid(node)
+          node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+          nodes_as_sids.each do |sid|
+            return Isomorfeus.instance_from_sid(node_sid) if sid == node_sid
+          end
+          nil
+        end
+      else
+        def find_by_sid(node)
+          node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+          nodes.each do |node|
+            return node if node.to_sid == node_sid
+          end
+          nil
+        end
+      end
+    end
+  end
+end