isomorfeus-data 1.0.0.zeta5 → 1.0.0.zeta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5625abbd413fd5cf21639fa6d0f582a2f041d23416192efe7b02cff14a887ce
-  data.tar.gz: 2cdec72d114889ea6e470b1e6dc7dc6d169b158221c5e5cbf242b6f9f431f215
+  metadata.gz: 8e3b35be6d60e990ded7a328e4024ed43dd3a23e14d3c5f6827f6d25fb6ffcd9
+  data.tar.gz: 8317a70faf17071ebb31bc2f9b6cff9047ae676a56e10ec9cdf5b768078f0abd
 SHA512:
-  metadata.gz: 4fd527598a4840d83d5f0d7fa85f00eb03663b6378595d498121a28f395b9dd5f03178127da1379655a4e50f094c019e5e3795c17e4e603b163b3f08c271be1f
-  data.tar.gz: 82eff7fb7ab7e6fc0572215cbc373f1e824e47711c18772c5135b7b5084da2444c5ffc6b4f32568554b109bd964d05f6caaf82edb4ca87d9d30e542eb580b73f
+  metadata.gz: 1480236015fee03d640bde3b30fe3f281e01809ec363c6f4ab8eceef79aa05017da92d6102d8f1d4ee6206576ace07859983d598b5043ee9a6fc77ba479e464f
+  data.tar.gz: ff340cfec0e01b915949e95ba10918aca57a8e299c18e822db84f536ceabd8be768a1fe1d4a2e2c631783e9b7657809838f12279a627525c1592ffe4bddc047e

data/README.md

@@ -1,3 +1,39 @@
 # isomorfeus-data
 
-see docs for now
+Data access for Isomorfeus.
+
+*Use Ruby for Graphs! ... and more!*
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
+
+### Overview
+
+Isomorfeus Data provides convenient access to all sorts of data for the distributes, isomorphic system.
+Data is available in the same way on clients and server.
+
+Isomorfeus Data supports arrays, hashes, collections, graphs, nodes, edges and compositions of any of those which can be loaded with one requests.
+
+All LucidData classes are database agnostic. Any ORM or data source supported by ruby can be used.
+Data must then be shaped (usually in to a Hash or Array) to fit the Isomorfeus Data classes.
+ 
+
+### Core Concepts and Common API
+
+- [Core Concepts](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/concepts.md)
+- [Common API](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/common_api.md)
+
+### Available Classes
+
+All classes follow the common principles and the common API above.
+
+- [LucidData::Array](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_array.md) - A array, easily accessible on client and server
+- [LucidData::Collections](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_collection.md) - A collection of LucidData::Node or LucidData::Vertex or LucidData::Document objects
+- [LucidData::Composition](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_composition.md) - A composition of any of those other classes, even graphs, for easy, one request access to arbitrary data
+- [LucidData::Document, LucidData::Node, LucidData::Vertex](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_node.md) - A node/document/vertex, can be used stand alone, in a collection or in a graph
+- [LucidData::Edge, LucidData::Link](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_edge.md) - A edge/link, can be used standalone, in a collection or in a graph
+- [LucidData::EdgeCollection, LucidData::LinkCollection](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_edge_collection.md)  - A collection of LucidData::Edge or LucidData::Link objects
+- [LucidData::Graph](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_graph.md) - A graph, which can be build from several LucidData::Collection objects and LucidData::EdgeCollection objects
+- [LucidData::Hash](https://github.com/isomorfeus/isomorfeus-framework/blob/master/ruby/isomorfeus-data/docs/data_hash.md) - A hash, easily accessible on client and server
+
+(more to come soon)

data/lib/isomorfeus/data/attribute_support.rb

@@ -0,0 +1,122 @@
+module Isomorfeus
+  module Data
+    module AttributeSupport
+      def self.included(base)
+        base.instance_exec do
+          def attribute_conditions
+            @attribute_conditions ||= {}
+          end
+
+          def valid_attribute?(attr_name, attr_value)
+            Isomorfeus::Props::Validator.new(self.name, attr_name, attr_value, attribute_conditions[attr_name]).validate!
+          rescue
+            false
+          end
+
+          def validate
+            Isomorfeus::Props::ValidateHashProxy.new
+          end
+        end
+
+        def _validate_attribute(attr_name, attr_val)
+          raise "#{@class_name} No such attribute declared: '#{attr_name}'!" unless self.class.attribute_conditions.key?(attr_name)
+          Isomorfeus::Props::Validator.new(@class_name, attr_name, attr_val, self.class.attribute_conditions[attr_name]).validate!
+        end
+
+        def exclude_attributes(*attrs)
+          @_excluded_attributes = attrs
+        end
+
+        def select_attributes(*attrs)
+          @_selected_attributes = attrs
+        end
+
+        if RUBY_ENGINE == 'opal'
+          base.instance_exec do
+            def attribute(name, options = {})
+              attribute_conditions[name] = options
+
+              define_method(name) do
+                _get_attribute(name)
+              end
+
+              define_method("#{name}=") do |val|
+                _validate_attribute(name, val)
+                changed!
+                @_changed_attributes[name] = val
+              end
+            end
+          end
+
+          def _get_attribute(name)
+            return @_changed_attributes[name] if @_changed_attributes.key?(name)
+            path = @_store_path + [name]
+            result = Redux.fetch_by_path(*path)
+            return nil if `result === null`
+            result
+          end
+
+          def _get_attributes
+            raw_attributes = Redux.fetch_by_path(*@_store_path)
+            hash = Hash.new(raw_attributes)
+            hash.merge!(@_changed_attributes) if @_changed_attributes
+            hash
+          end
+
+          def _get_selected_attributes
+            attributes = _get_attributes.dup
+            if @_selected_attributes && !@_selected_attributes.empty?
+              attributes.each_key do |attr|
+                unless @_selected_attributes.include?(attr) || @_selected_attributes.include?(attr)
+                  attributes.delete(attr)
+                end
+              end
+            end
+            if @_excluded_attributes && !@_excluded_attributes.empty?
+              @_excluded_attributes.each { |attr| attributes.delete(attr) }
+            end
+            attributes
+          end
+        else
+          base.instance_exec do
+            def attribute(name, options = {})
+              attribute_conditions[name] = options
+
+              define_method(name) do
+                @_raw_attributes[name]
+              end
+
+              define_method("#{name}=") do |val|
+                _validate_attribute(name, val)
+                changed!
+                @_raw_attributes[name] = val
+              end
+            end
+          end
+
+          def _get_attributes
+            @_raw_attributes
+          end
+
+          def _get_selected_attributes
+            attributes = _get_attributes.transform_keys(&:to_s)
+            self.class.attribute_conditions.each do |attr, options|
+              attributes.delete(attr.to_s) if options[:server_only]
+            end
+            if @_selected_attributes && !@_selected_attributes.empty?
+              attributes.each_key do |attr|
+                unless @_selected_attributes.include?(attr.to_sym) || @_selected_attributes.include?(attr)
+                  attributes.delete(attr)
+                end
+              end
+            end
+            if @_excluded_attributes && !@_excluded_attributes.empty?
+              @_excluded_attributes.each { |attr| attributes.delete(attr.to_s) }
+            end
+            attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/config.rb

@@ -1,116 +1,106 @@
 module Isomorfeus
   # available settings
   class << self
-    def cached_array_classes
-      @cached_array_classes ||= {}
+    def instance_from_sid(sid)
+      data_class = cached_data_class(sid[0])
+      data_class.new(key: sid[1])
     end
 
-    def cached_array_class(class_name)
-      return cached_array_classes[class_name] if cached_array_classes.key?(class_name)
-      cached_array_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    def cached_collection_classes
-      @cached_collection_classes ||= {}
-    end
-
-    def cached_collection_class(class_name)
-      return cached_collection_classes[class_name] if cached_collection_classes.key?(class_name)
-      cached_collection_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    def cached_edge_classes
-      @cached_edge_classes ||= {}
-    end
-
-    def cached_edge_class(class_name)
-      return cached_edge_classes[class_name] if cached_edge_classes.key?(class_name)
-      cached_edge_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    def cached_graph_classes
-      @cached_graph_classes ||= {}
-    end
-
-    def cached_graph_class(class_name)
-      return cached_graph_classes[class_name] if cached_graph_classes.key?(class_name)
-      cached_graph_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    def cached_hash_classes
-      @cached_hash_classes ||= {}
-    end
-
-    def cached_hash_class(class_name)
-      return cached_hash_classes[class_name] if cached_hash_classes.key?(class_name)
-      cached_hash_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    def cached_node_classes
-      @cached_node_classes ||= {}
-    end
-
-    def cached_node_class(class_name)
-      return cached_node_classes[class_name] if cached_node_classes.key?(class_name)
-      cached_node_classes[class_name] = "::#{class_name}".constantize
-    end
-
-    if RUBY_ENGINE != 'opal'
-      def valid_array_class_names
-        @valid_array_class_names ||= Set.new
-      end
-
-      def valid_array_class_name?(class_name)
-        valid_array_class_names.include?(class_name)
+    if RUBY_ENGINE == 'opal'
+      def cached_data_classes
+        @cached_data_classes ||= `{}`
       end
 
-      def add_valid_array_class(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        valid_array_class_names << class_name
+      def cached_data_class(class_name)
+        return "::#{class_name}".constantize if Isomorfeus.development?
+        return cached_data_classes.JS[class_name] if cached_data_classes.JS[class_name]
+        cached_data_classes.JS[class_name] = "::#{class_name}".constantize
       end
-
-      def valid_collection_class_names
-        @valid_collection_class_names ||= Set.new
+    else
+      def cached_data_classes
+        @cached_data_classes ||= {}
       end
 
-      def valid_collection_class_name?(class_name)
-        valid_collection_class_names.include?(class_name)
+      def cached_data_class(class_name)
+        return "::#{class_name}".constantize if Isomorfeus.development?
+        return cached_data_classes[class_name] if cached_data_classes.key?(class_name)
+        cached_data_classes[class_name] = "::#{class_name}".constantize
       end
 
-      def add_valid_collection_class(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        valid_collection_class_names << class_name
+      def valid_data_classes
+        @valid_data_classes ||= {}
       end
 
-      def valid_graph_class_names
-        @valid_graph_class_names ||= Set.new
+      def valid_data_class_name?(class_name)
+        valid_data_classes.key?(class_name)
       end
 
-      def valid_graph_class_name?(class_name)
-        valid_graph_class_names.include?(class_name)
+      def add_valid_data_class(klass)
+        valid_data_classes[raw_class_name(klass)] = true
       end
 
-      def add_valid_graph_class(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        valid_graph_class_names << class_name
+      def connect_to_arango
+        arango_options = if Isomorfeus.production? then Isomorfeus.arango_production
+                         elsif Isomorfeus.development? then Isomorfeus.arango_development
+                         elsif Isomorfeus.test? then Isomorfeus.arango_test
+                         end
+        arango_options = {}.merge(arango_options)
+        database = arango_options.delete(:database)
+        Arango.connect_to(**arango_options)
+        begin
+          Arango.current_server.get_database(database)
+        rescue Exception => e
+          raise "Can't connect to database '#{database}' (#{e.message})."
+        end
       end
 
-      def valid_hash_class_names
-        @valid_hash_class_names ||= Set.new
+      def prepare_arango_database
+        #arango_options = if Isomorfeus.production? then Isomorfeus.arango_production
+        #                 elsif Isomorfeus.development? then Isomorfeus.arango_development
+        #                 elsif Isomorfeus.test? then Isomorfeus.arango_test
+        #                 end
+        #arango_options = {}.merge(arango_options)
+        #database = arango_options.delete(:database)
+        #Arango.connect_to(**arango_options)
+        #db = nil
+        #begin
+        #  opened_db = Arango.current_server.get_database(database)
+        #  db = opened_db.name
+        #rescue Exception => e
+        #  db = nil
+        #  unless e.message.include?('database not found')
+        #    raise "Can't check if database '#{database}' exists."
+        #  end
+        #end
+        #unless db
+        #  begin
+        #    Arango.current_server.create_database(database)
+        #  rescue Exception => e
+        #    raise "Can't create database '#{database}' (#{e.message}).\nPlease make sure database '#{database}' exists."
+        #  end
+        #  begin
+        #    Arango.current_server.get_database(database)
+        #  rescue Exception => e
+        #    raise "Can't connect to database '#{database}' (#{e.message})."
+        #  end
+        #end
+        #
+        #Arango.current_server.install_opal_module(database)
+        #unless Arango.current_database.collection_exist?('IsomorfeusSessions')
+        #  Arango.current_database.create_collection('IsomorfeusSessions')
+        #end
+        #unless Arango.current_database.collection_exist?('IsomorfeusObjectStore')
+        #  Arango.current_database.create_collection('IsomorfeusObjectStore')
+        #end
       end
 
-      def valid_hash_class_name?(class_name)
-        valid_hash_class_names.include?(class_name)
+      def arango_configured?
+        !!(Isomorfeus.arango_production && Isomorfeus.arango_development && Isomorfeus.arango_test)
       end
 
-      def add_valid_hash_class(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        valid_hash_class_names << class_name
-      end
+      attr_accessor :arango_production
+      attr_accessor :arango_development
+      attr_accessor :arango_test
     end
   end
 end

data/lib/isomorfeus/data/element_validator.rb

@@ -0,0 +1,133 @@
+module Isomorfeus
+  module Data
+    class ElementValidator
+      def initialize(source_class, element, options)
+        @c = source_class
+        @e = element
+        @o = options
+      end
+
+      def validate!
+        ensured = ensure!
+        unless ensured
+          cast!
+          type!
+        end
+        run_checks!
+        true
+      end
+
+      private
+
+      # basic tests
+
+      def cast!
+        if @o.key?(:cast)
+          begin
+            @e = case @o[:class]
+                 when Integer then @e.to_i
+                 when String then @e.to_s
+                 when Float then @e.to_f
+                 when Array then @e.to_a
+                 when Hash then @e.to_h
+                 end
+            @e = !!@e if @o[:type] == :boolean
+          rescue
+            raise "#{@c}: #{@p} cast failed" unless @e.class == @o[:class]
+          end
+        end
+      end
+
+      def ensure!
+        if @o.key?(:ensure)
+          @e = @o[:ensure] unless @e
+          true
+        elsif @o.key?(:ensure_block)
+          @e = @o[:ensure_block].call(@e)
+          true
+        else
+          false
+        end
+      end
+
+      def type!
+        return if @o[:allow_nil] && @e.nil?
+        if @o.key?(:class)
+          raise "#{@c}: #{@p} class not #{@o[:class]}" unless @e.class == @o[:class]
+        elsif @o.key?(:is_a)
+          raise "#{@c}: #{@p} is not a #{@o[:is_a]}" unless @e.is_a?(@o[:is_a])
+        elsif @o.key?(:type)
+          case @o[:type]
+          when :boolean
+            raise "#{@c}: #{@p} is not a boolean" unless @e.class == TrueClass || @e.class == FalseClass
+          end
+        end
+      end
+
+      # all other checks
+
+      def run_checks!
+        if @o.key?(:validate)
+          @o[:validate].each do |m, l|
+            send('c_' + m, l)
+          end
+        end
+      end
+
+      # specific validations
+      def c_gt(v)
+        raise "#{@c}: #{@p} not greater than #{v}!" unless @e > v
+      end
+
+      def c_lt(v)
+        raise "#{@c}: #{@p} not less than #{v}!" unless @e < v
+      end
+
+      def c_keys(v)
+        raise "#{@c}: #{@p} keys dont fit!" unless @e.keys.sort == v.sort
+      end
+
+      def c_size(v)
+        raise "#{@c}: #{@p} length/size is not #{v}" unless @e.size == v
+      end
+
+      def c_matches(v)
+        raise "#{@c}: #{@p} does not match #{v}" unless v.match?(@e)
+      end
+
+      def c_max(v)
+        raise "#{@c}: #{@p} is larger than #{v}" unless @e <= v
+      end
+
+      def c_min(v)
+        raise "#{@c}: #{@p} is smaller than #{v}" unless @e >= v
+      end
+
+      def c_max_size(v)
+        raise "#{@c}: #{@p} is larger than #{v}" unless @e.size <= v
+      end
+
+      def c_min_size(v)
+        raise "#{@c}: #{@p} is smaller than #{v}" unless @e.size >= v
+      end
+
+      def c_direction(v)
+        raise "#{@c}: #{@p} is positive" if v == :negative && @e >= 0
+        raise "#{@c}: #{@p} is negative" if v == :positive && @e < 0
+      end
+
+      def c_test
+        raise "#{@c}: #{@p} test condition check failed" unless @o[:test].call(@e)
+      end
+
+      def c_sub_type(v)
+        case v
+        when :email
+          # TODO
+        when :url
+          # TODO
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/generic_class_api.rb

@@ -0,0 +1,155 @@
+module Isomorfeus
+  module Data
+    module GenericClassApi
+      if RUBY_ENGINE == 'opal'
+        def create(key:, **things)
+          instance = new(key: key, **things)
+          instance.promise_save
+          instance
+        end
+
+        def promise_create(key:, **things)
+          new(key: key, **things).promise_save
+        end
+
+        def destroy(key:)
+          promise_destroy(key: key)
+          true
+        end
+
+        def promise_destroy(key:)
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :destroy, key: key).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_DESTROY', data: agent.full_response[:data])
+              agent.result = true
+            end
+          end
+        end
+
+        def load(key:)
+          instance = self.new(key: key)
+          self.promise_load(key: key, instance: instance) unless instance.loaded?
+          instance
+        end
+
+        def promise_load(key:, instance: nil)
+          instance = self.new(key: key) unless instance
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key).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
+              instance._load_from_store!
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
+              agent.result = instance
+            end
+          end
+        end
+
+        def promise_query(props = {})
+          validate_props(props)
+          props_json = props.to_json
+          instance = self.new(key) unless instance
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, 'query', 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
+
+        # execute
+        def execute_destroy(_); end
+        def execute_load(_); end
+        def execute_query(_); end
+        def execute_save(_); end
+
+        # callbacks
+        def on_destroy(_); end
+        def on_load(_); end
+        def on_query(_); end
+        def on_save(_); end
+      else
+        def promise_create(key:, **things)
+          instance = self.create(key: key, **things)
+          result_promise = Promise.new
+          result_promise.resolve(instance)
+          result_promise
+        end
+
+        def promise_destroy(key:)
+          self.destroy(key: key)
+          result_promise = Promise.new
+          result_promise.resolve(true)
+          result_promise
+        end
+
+        def promise_load(key:)
+          instance = self.load(key: key)
+          result_promise = Promise.new
+          result_promise.resolve(instance)
+          result_promise
+        end
+
+        def promise_query(props)
+          instance = self.query(props)
+          result_promise = Promise.new
+          result_promise.resolve(instance)
+          result_promise
+        end
+
+        # execute
+        def execute_destroy(&block)
+          @_destroy_block = block
+        end
+
+        def execute_load(&block)
+          @_load_block = block
+        end
+
+        def execute_query(&block)
+          @_query_block = block
+        end
+
+        def execute_save(&block)
+          @_save_block = block
+        end
+
+        # callbacks
+        def on_destroy(&block)
+          @_on_destroy_block = block
+        end
+
+        def on_load(&block)
+          @_on_load_block = block
+        end
+
+        def on_query(&block)
+          @_on_query_block = block
+        end
+
+        def on_save(&block)
+          @_on_save_block = block
+        end
+      end
+    end
+  end
+end