isomorfeus-data 1.0.0.zeta5 → 1.0.0.zeta6

data/lib/lucid_hash/mixin.rb

@@ -1,168 +0,0 @@
-module LucidHash
-  module Mixin
-    def self.included(base)
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_hash_class(base) unless base == LucidHash::Base
-      end
-
-      base.extend(LucidPropDeclaration::Mixin)
-
-      def to_gid
-        [@class_name, @props_json]
-      end
-
-      def to_transport(inline: false)
-        if inline
-          { '_inline' => { @props_json => to_h }}
-        else
-          { 'hashes' => { @class_name => { @props_json => to_h }}}
-        end
-      end
-
-      base.instance_exec do
-        def on_load_block
-          @on_load_block
-        end
-
-        def query_block
-          @query_block
-        end
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def initialize(store_path: nil, validated_props: nil)
-          @props = validated_props
-          @props_json = @props.to_json if @props
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @store_path = store_path ? store_path : [:data_state, :hashes, @class_name]
-        end
-
-        def loaded?
-          Redux.fetch_by_path(*(@store_path + [@props_json])) ? true : false
-        end
-
-        def [](name)
-          path = @store_path + [@props_json, name]
-          result = Redux.fetch_by_path(*path)
-          result ? result : nil
-        end
-
-        def key?(name)
-          path = @store_path + [@props_json, name]
-          Redux.fetch_by_path(*path) ? true : false
-        end
-
-        def method_missing(method_name, *args, &block)
-          path = @store_path + [@props_json]
-          raw_hash = Redux.fetch_by_path(*path)
-          if raw_hash
-            Hash.new(raw_hash).send(method_name, *args, &block)
-          else
-            Hash.new.send(method_name, *args, &block)
-          end
-        end
-
-        def to_h
-          raw_hash = Redux.fetch_by_path(*(@store_path + [@props_json]))
-          raw_hash ? Hash.new(raw_hash) : {}
-        end
-
-        base.instance_exec do
-          def load(props_hash = {})
-            validate_props(props_hash)
-            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            self.promise_load(props_hash, instance) unless instance.loaded?
-            instance
-          end
-
-          def on_load(&block)
-          end
-
-          def promise_load(props_hash = {}, instance = nil)
-            unless instance
-              validate_props(props_hash)
-              instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            end
-
-            props_json = instance.instance_variable_get(:@props_json)
-
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::HashLoadHandler', self.name, props_json).then do |agent|
-              if agent.processed
-                agent.result
-              else
-                agent.processed = true
-                if agent.response.key?(:error)
-                  `console.error(#{agent.response[:error].to_n})`
-                  raise agent.response[:error]
-                end
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-                agent.result = instance
-              end
-            end
-          end
-
-          def query
-            nil
-          end
-        end
-      else # RUBY_ENGINE
-        unless base == LucidHash::Base
-          base.prop :pub_sub_client, default: nil
-          base.prop :current_user, default: nil
-        end
-
-        def initialize(store_path: nil, validated_props: nil)
-          @props = validated_props
-          @props_json = @props.to_json if @props
-          @loaded = false
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def [](name)
-          @data_hash[name]
-        end
-
-        def method_missing(method_name, *args, &block)
-          @data_hash.send(method_name, *args, &block)
-        end
-
-        def to_h
-          @data_hash.to_h.transform_keys { |k| k.to_s }
-        end
-
-        base.instance_exec do
-          def load(props_hash = {})
-            validate_props(props_hash)
-            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            instance.instance_exec do
-              @data_hash = self.class.query_block.call(props_hash)
-              @loaded = true
-            end
-            instance
-          end
-
-          def on_load(&block)
-            @on_load_block = block
-          end
-
-          def promise_load(props_hash = {}, instance = nil)
-            instance = self.load(props_hash)
-            result_promise = Promise.new
-            result_promise.resolve(instance)
-            result_promise
-          end
-
-          def query(&block)
-            @query_block = block
-          end
-        end
-      end  # RUBY_ENGINE
-    end
-  end
-end

data/lib/lucid_node/base.rb

@@ -1,5 +0,0 @@
-module LucidNode
-  class Base
-    include LucidNode::Mixin
-  end
-end

data/lib/lucid_node/mixin.rb

@@ -1,198 +0,0 @@
-# api
-# class:
-#   attribute :my_attribute, server_only: false|true, class: ClassName, is_a: ClassName, default: value, validate: block
-#   my_node.class.attributes
-#   my_node.class.attribute_options
-# instance:
-#   my_node.my_attribute
-#   my_node.my_attribute = value
-#   my_node.changed_attributes
-#   my_node.changed?
-#   my_node.loaded?
-#   my_node.valid_attribute?(attr, value)
-#   my_node.validate_attribute!(attr, value)
-#   my_node.to_transport
-
-module LucidNode
-  module Mixin
-    def self.included(base)
-      attr_reader :id
-
-      def ==(other_node)
-        eql?(other_node)
-      end
-
-      def eql?(other_node)
-        @id == other_node.id && @class_name == other_node.instance_variable_get(:@class_name)
-      end
-
-      def id=(new_id)
-        new_id = new_id.to_s
-        changed_attributes[:id] = new_id
-        @id = new_id
-      end
-
-      def changed_attributes
-        @changed_attributes ||= Isomorfeus::Data::Props.new({})
-      end
-
-      def changed?
-        changed_attributes.any?
-      end
-
-      def to_cid
-        [@class_name, @id]
-      end
-
-      def valid_attribute?(attr, value)
-        begin
-          validate_attribute!(attr, value)
-          true
-        rescue
-          false
-        end
-      end
-
-      def validate_attribute!(attr, value)
-        attr_options = self.class.attribute_options[attr]
-
-        if attr_options.key?(:class)
-          raise "#{attr}: value class is not #{attr_options[:class]}!" unless value.class == attr_options[:class]
-        end
-
-        if attr_options.key?(:is_a)
-          raise "#{attr}: value is not a #{attr_options[:class]}!" unless value.is_a?(attr_options[:is_a])
-        end
-
-        if attr_options.key?(:validate)
-          raise "#{attr}: value failed validation!" unless attr_options[:validate].call(value)
-        end
-      end
-
-      base.instance_exec do
-        def query_block
-          @query_block
-        end
-
-        def attributes
-          attribute_options.keys
-        end
-
-        def attribute_options
-          @attribute_options ||= { id: {} }
-        end
-
-        def node_from_cid(cid)
-          Isomorfeus.cached_node_class(cid[0]).new({id: cid[1]})
-        end
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def initialize(attributes_hash = nil)
-          attributes_hash = {} unless attributes_hash
-          self.class.attributes.each do |attr|
-            if attributes_hash.key?(attr)
-              validate_attribute!(attr, attributes_hash[attr])
-              changed_attributes[attr] = attributes_hash[attr]
-            elsif self.class.attribute_options[attr].key?(:default)
-              changed_attributes[attr] = self.class.attribute_options[attr][:default]
-            end
-          end
-          @id = attributes_hash[:id].to_s
-          @id = "new_#{object_id}" if @id.empty?
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-        end
-
-        def loaded?
-          Redux.fetch_by_path(:data_state, :node, @class_name, :instances, @id) ? true : false
-        end
-
-        def to_transport(*args)
-          final_attributes = {}
-          self.class.attributes.each do |attr|
-            next if attr == :id
-            final_attributes[attr] = send(attr)
-          end
-          { 'nodes' => { @class_name => { @id => { attributes: final_attributes }}}}
-        end
-
-        base.instance_exec do
-          def attribute(name, options = {})
-            attribute_options[name] = options
-
-            define_method(name) do
-              if changed_attributes.key?(name)
-                changed_attributes[name]
-              else
-                Redux.fetch_by_path(:data_state, :nodes, @class_name, @id, :attributes, name)
-              end
-            end
-
-            define_method("#{name}=") do |arg|
-              validate_attribute!(name, arg)
-              changed_attributes.set(name, arg)
-            end
-          end
-
-          def query
-            nil
-          end
-        end
-      else # RUBY_ENGINE
-        def initialize(attributes_hash = nil)
-          attributes_hash = {} unless attributes_hash
-          given_attributes = Isomorfeus::Data::Props.new(attributes_hash)
-          valid_attributes_hash = {}
-          self.class.attributes.each do |attr|
-            if given_attributes.key?(attr)
-              validate_attribute!(attr, given_attributes[attr])
-              valid_attributes_hash[attr] = given_attributes[attr]
-            elsif self.class.attribute_options[attr].key?(:default)
-              valid_attributes_hash[attr] = self.class.attribute_options[attr][:default]
-            end
-          end
-          @attributes = Isomorfeus::Data::Props.new(valid_attributes_hash)
-          @id = @attributes[:id].to_s
-          @id = "new_#{object_id}" if @id.empty?
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-        end
-
-        def loaded?
-          true
-        end
-
-        def to_transport(*args)
-          final_attributes = {}
-          self.class.attributes.each do |attr|
-            next if attr == :id
-            include_attribute = @attributes.key?(attr)
-            include_attribute = !self.class.attribute_options[attr][:server_only] if self.class.attribute_options[attr].key?(:server_only)
-            final_attributes[attr.to_s] = send(attr) if include_attribute
-          end
-          { 'nodes' => { @class_name => { @id => { 'attributes' => final_attributes }}}}
-        end
-
-        base.instance_exec do
-          def attribute(name, options = {})
-            attribute_options[name] = options
-
-            define_method(name) do
-              if changed_attributes.key?(name)
-                changed_attributes[name]
-              else
-                @attributes[name]
-              end
-            end
-
-            define_method("#{name}=") do |arg|
-              validate_attribute!(name, arg)
-              changed_attributes.set(name, arg)
-            end
-          end
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end