lims-core 3.2.3

data/lib/lims-core/persistence/state_group.rb

@@ -0,0 +1,97 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'lims-core/persistence/state_list'
+module Lims::Core
+  module Persistence
+    # A immutable list of {ResourceState}.
+    class StateGroup < StateList
+      attr_reader :persistor
+      def initialize(persistor, states)
+        @persistor = persistor
+        super(states)
+      end
+      def groups
+        [self]
+      end
+
+      def new(&block)
+        self.class.new(self.persistor, block.call)
+      end
+
+      def save
+        # @todo method for that.
+        all_parents = StateList.new
+        each do |state|
+          next if state.resource == nil or state.to_delete
+          state.parents!.andtap do |parents|
+            all_parents.merge(parents)
+          end
+        end
+
+        all_parents.save
+
+        persistor.purge_invalid_object
+
+        # split by status
+        group_by(&:save_action).tap do |groups|
+          groups[:delete].andtap { |group|  StateGroup.new(persistor, group).destroy }
+          groups[:update].andtap { |group| persistor.bulk_update(group) }
+          groups[:insert].andtap { |group| persistor.bulk_insert(group) }
+        end
+
+        all_children = StateList.new
+        each do |state|
+          next unless state.resource
+          state.body_saved!
+          state.children!.andtap do |children|
+            all_children.merge(children)
+          end
+        end
+        all_children.save
+      end
+
+      # @todo doc
+      # destroy because delete exists already for a Set
+      def destroy
+        return self if size == 0
+         # mark each item for deletion
+         # so the parents are not saved later.
+         # children needs to be deleted NOW to avoid
+         # foreign key constraint error.
+          each_with_object(StateList.new) do |state, list|
+            # don't delete children if they've been deleted already
+            next if state.children_saved?
+            state.mark_for_deletion
+            list.merge(persistor.deletable_children_for(state.resource))
+            state.children_saved!
+          end.destroy
+
+        
+        persistor.bulk_delete(self.select { |s| !s.body_saved? })
+
+          each_with_object(StateList.new) do |state, list|
+            next if state.parents_saved?
+            list.merge(persistor.deletable_parents_for(state.resource))
+            state.parents_saved!
+          end.destroy
+        each { |state| state.body_saved! }
+
+      end
+
+      def load(*params)
+        to_load = select(&:to_load?)
+        all_parents = StateList.new
+        attributes_list = []
+        persistor.bulk_load(to_load, *params) do |att|
+          all_parents.merge(persistor.parents_for_attributes(att))
+          attributes_list << att
+        end
+        all_parents.load(*params)
+        attributes_list.map do |att|
+          persistor.new_from_attributes(att)
+        end
+        persistor.load_children(self, *params)
+        self
+      end
+    end
+  end
+end

data/lib/lims-core/persistence/state_list.rb

@@ -0,0 +1,56 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'lims-core/persistence/resource_state'
+require 'set'
+module Lims::Core
+  module Persistence
+    # A immutable list of {ResourceState}.
+    class StateList < Set
+      # @return [List<StateGroup>]
+      def groups
+        persistor_order = map { |state| state.persistor}.uniq
+        grouped = group_by { |state| state.persistor }
+        persistor_order.map do  |persistor|
+            StateGroup.new(persistor, grouped[persistor])
+          end
+      end
+
+      # We need to redefine some basic array function
+      # to keep the current class and not return an array
+      %w(select).each do |method|
+        define_method(method) do |&block|
+          new { super(&block) }
+        end
+      end
+
+      def new(&block)
+        self.class.new(block.call)
+      end
+
+      def save
+        groups.each do |group|
+          group.save
+        end
+      end
+
+      def destroy
+        groups.each do |group|
+          group.destroy
+        end
+      end
+
+      # @todo return object according to initial order ?
+      def load
+        groups.each do |group|
+          group.load
+        end
+      end
+
+      def reset_status
+        each { |state|
+          state.reset }
+      end
+
+    end
+  end
+end
+require 'lims-core/persistence/state_group'

data/lib/lims-core/persistence/store.rb

@@ -0,0 +1,73 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'common'
+
+require 'lims-core/persistence'
+require 'lims-core/persistence/session'
+
+module Lims::Core
+    module  Persistence
+      # A store represents a persistent datastore, where object can be saved and restored.
+      # A connection to a database, for example.
+      class Store
+        def self.const_missing(name)
+          super(name)
+        end
+
+        # The dirty-attribute strategy decides
+        # how object modification is detected
+        # to avoid saved unmodified object.
+        attr_accessor :dirty_attribute_strategy
+        DIRTY_ATTRIBUTE_STRATEGY_DEEP_COPY = 1
+        DIRTY_ATTRIBUTE_STRATEGY_SHA1 = 2
+        DIRTY_ATTRIBUTE_STRATEGY_MD5 = 3
+        DIRTY_ATTRIBUTE_STRATEGY_QUICK_HASH = 4
+        attr_accessor :dirty_attribute_strategy
+
+        # Retrieves the effective module of a class
+        # Useful to call "sibling" classes.
+        # @example
+        #   class Sequel::Store < Store
+        #     def session
+        #        base_module::Session
+        #   end
+        #
+        #   session will return a Sequel::Session instead of a ::Session.
+        #
+        # @return [Module]
+        def self.base_module
+          @base_module ||= begin
+                            base_name = name.sub(/::\w+$/, '')
+                            constant(base_name)
+                          end
+        end
+        def base_module
+          self.class.base_module
+        end
+
+        # Create a session and pass it to the block.
+        # This is the only way to get a session.
+        # @param [Array]
+        # @yieldparam [Session] session the created session.
+        # @return the value of the block
+        def with_session(*params, &block)
+          create_session(*params).with_session(&block)
+        end
+
+
+        # Create a session
+        # If a session is given a parameter
+        # return in instead of creating a new one.
+        def create_session(*params)
+          return params.first if(params.size >= 1 && params.first.is_a?(Session))
+          base_module::Session.new(self, *params)
+        end
+
+        # Execute given block within a transaction
+        # If it make sense.
+        def transaction
+          yield
+        end
+      end
+    end
+end
+

data/lib/lims-core/persistence/uuid_resource.rb

@@ -0,0 +1,115 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'common'
+require 'uuid'
+
+require 'lims-core/resource'
+require 'lims-core/persistence/resource_state'
+
+module Lims::Core
+    module Persistence
+      # Bind a uuid (as a String) to a Resource (a key and a model)
+      # The key is a FixNum to find the corresponding resource in the store
+      # and the model is the real class of the object (or at least something allowing to find it)
+      # the `state` attribute is the {ResourceState} corresponding to linked {Resource}.
+      class UuidResource
+        include Resource
+        attribute :state, ResourceState, :writer => :private, :initializable => true
+        attribute :model_class, Class, :writer => :private, :initializable => true
+        attribute :uuid, String, :writer => :private, :initializable => true
+
+        def initialize(*args)
+          super(*args)
+        end
+
+        # Link the resouce state to the UuidResource itself
+        def state=(state_)
+          @state = state_
+          if state_
+            state_.uuid_resource = self
+          end
+        end
+
+        # for speed
+        def attributes
+          {state: state,
+            model_class: model_class,
+            uuid: uuid
+          }
+        end
+
+        def attributes_for_dirty
+          {state: state,
+            model_class: model_class,
+          }.tap do |att|
+            att[:uuid] = @uuid if @uuid
+          end
+        end
+        
+        class InvalidUuidError < RuntimeError
+        end
+
+        Generator = UUID.new
+        Form = [8, 4, 4, 4, 12]
+        Length = Form.inject { |m, n| m+n }
+        ValidationRegexp = /#{Form.map { |n| "[0-9a-f]{#{n}}" }.join('-')}/i
+        SplitRegexp = /#{Form.map { |n| "([0-9a-f]{#{n}})"}.join('')}/
+
+
+        def key
+          @state.andtap { |state|  state.id }
+        end
+
+        def self.valid?(uuid)
+          !!(uuid =~ ValidationRegexp)
+        end
+
+        def self.generate_uuid()
+          Generator.generate
+        end
+
+        # Pack a string representation of an uuid to a char(16)
+        def self.pack(to_pack)
+          [compact(to_pack)].pack("H*")
+        end
+
+        def self.unpack(packed)
+          expand(packed.unpack("H*").first)
+        end
+
+        # Convert the string representation of an Uuid to a bignum
+        # @param [String] s
+        # @return [Bignum]
+        def self.string_to_bignum(s)
+          compact(s).to_i(16)
+        end
+
+        # Convert a bignum to a string representation 
+        # @param [Bignum] b
+        # @return [String]
+        def self.bignum_to_string(b)
+          l = Form.inject { |m, n| m+n }
+          expand("%0.*x" % [l,b])
+        end
+
+        def self.expand(s)
+          match = SplitRegexp.match(s)
+          raise InvalidUuidError.new(s) unless match
+          match.captures.join('-')
+        end
+
+        def self.compact(s)
+          s.tr('-', '')
+        end
+
+        def build_resource(attributes)
+          model_class.new(attributes)
+        end
+        protected :build_resource
+
+        def uuid
+          @uuid ||= UuidResource.generate_uuid
+        end
+      end
+    end
+end
+

data/lib/lims-core/persistence/uuid_resource_persistor.rb

@@ -0,0 +1,43 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+require 'common'
+
+require 'lims-core/persistence/persistor'
+require 'lims-core/persistence/uuid_resource'
+
+module Lims::Core
+  module  Persistence
+    class UuidResource
+      class UuidResourcePersistor < Persistence::Persistor
+        Model = UuidResource
+
+        def parents_for(resource)
+          resource.state && resource.state.resource ? [resource.state] : []
+        end
+
+        def filter_attributes_on_save(attributes)
+          attributes.mash do |k,v|
+            case k
+            when :model_class then   [ k, @session.model_name_for(v) ]
+            when :uuid then [ k, @session.pack_uuid(v) ]
+            when :state
+              [:key, v && v.id]
+            else [k, v]
+            end
+          end
+        end
+
+        def filter_attributes_on_load(attributes)
+          attributes.mash do |k,v|
+            case k
+            when :model_class then [ k, @session.class_for(v) ]
+            when :uuid then [ k, @session.unpack_uuid(v) ]
+            when :key then [:state, @session.persistor_for(attributes[:model_class]).state_for_id(attributes[:key])]
+            else [k, v]
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/lims-core/persistence/uuidable.rb

@@ -0,0 +1,107 @@
+# vi: ts=2:sts=2:et:sw=2 spell:spelllang=en
+
+require 'sequel'
+require 'lims-core/persistence'
+require 'lims-core/persistence/uuid_resource_persistor'
+
+module Lims::Core
+  module Persistence
+    # Add uuid behavior (lookup and creation) to a Session
+    module Uuidable
+      # lookup one or more objects  by uuid or resource_uuid
+      # @param [String, Arrary<String>, UUidResource] args 
+      # @return [Resource, nil, Array<Resource>]
+      def [](args)
+        case args
+        when UuidResource then for_uuid_resource(args)
+        when String then for_uuid(args)
+        when Array then for_uuids(args)
+        else
+          super(args)
+        end
+      end
+
+      # Retrieve  id from an object or a Hash with a uuid key
+      # A list of uuids will 
+      def id_for(object)
+        case object
+        when Array
+          object.map { |o| id_for(o) }
+        when Hash
+          id_for(object[:uuid] || object["uuid"])
+        when String 
+          # We assume it is an uuid
+          self.uuid_resource[:uuid => pack_uuid(object)].andtap {  |ur| ur.key }
+        else
+          super
+        end
+      end
+      # Compute the name (string) used to be saved in the Uuid table.
+      # @param [Class] model_class class of the resource
+      # @return [String]
+      def model_name_for(model_class)
+        persistor_name_for(model_class)
+      end
+
+      # Get the class from the class name. Inverse of {#model_name_for}.
+      def class_for(model_name)
+        persistor_for(model_name).model
+      end
+
+      def new_uuid_resource_for(object)
+        UuidResource.new(:state => state_for(object), :model_class => object.class).tap do |r|
+          self << r
+        end
+      end
+
+      def uuid_resource_for(object)
+        state, object = object.is_a?(ResourceState) ? [object, object.resource] : [state_for(object), object]
+        self.uuid_resource[:key => state.id, :model_class => model_name_for(object.class)]
+      end
+
+      # Finds the uuid of an object if it exists
+      def uuid_for(object)
+        # We need to check if the object is managed and have alreday an id
+        raise RuntimeError, "Unmanaged object, #{object.inspect}" unless managed?(object)
+        state = state_for(object)
+        state.uuid_resource.andtap { |ur| return ur.uuid }
+        state.id && uuid_resource_for(state).andtap { |r|  r.uuid }
+      end
+
+
+      # Find or create a uuid for an object
+      def uuid_for!(object)
+        uuid_for(object) || new_uuid_resource_for(object).uuid
+      end
+
+      # Delete the underlying resource of a UuidResource
+      # @param [UuidResource] uuid_resource
+      # @return [Id, nil] 
+      def delete_resource(uuid_resource)
+        delete(for_uuid_resource(uuid_resource))
+        uuid_resource.key
+      end
+
+
+      protected
+      # find/load the object referenced by a uuid resource.
+      # Don't need to be called explicitely. use session[resource_uuid] instead
+      # @param [UuidResource] uuid_resource
+      # @return [Resource]
+      def for_uuid_resource(uuid_resource)
+          persistor_for(uuid_resource.model_class)[uuid_resource.key]
+      end
+
+      def for_uuid(uuid)
+        self.uuid_resource[:uuid => uuid].andtap do |r|
+          for_uuid_resource(r)
+        end
+      end
+
+      # @todo bulk load
+      def for_uuids(uuids)
+        uuids.map { |u| for_uuid(u) }.compact
+      end
+    end
+  end
+end