dgrid 0.0.2

data/lib/dgrid/api/place.rb

@@ -0,0 +1,47 @@
+module Dgrid
+  module API
+    class Place < NamedEntity
+      attr_accessor :lat_long
+
+      option :name, String, :required     # unique for this workspace 
+      option :description, String         # typically an address
+      option :lat_long, GPSCoordinates   # When known. Description will be geocoded if this is not supplied.
+      option :latitude, String           # alternative input method for db restoration
+      option :longitude, String
+      option :elevation, String
+      def initialize(options)
+      	parent_opts, my_opts = split_hash(options,[:name, :description])
+      	super(parent_opts)
+        gps_opts, other_opts = split_hash(options,[:latitude, :longitude, :elevation])
+      	set_members_from_hash(other_opts)
+        if !other_opts.include?(:lat_long) && !gps_opts.empty?
+          self.lat_long = coalesce_gps_opts(gps_opts)
+        end
+      end
+
+
+      def self.db_fields
+        %w(id name description latitude longitude elevation)
+      end
+
+      def self.pluralized
+        'places'
+      end
+      
+      def to_hash
+        h = super
+        if lat_long
+          h.merge!({:latitude => lat_long.lat, :longitude => lat_long.long, :elevation => lat_long.elevation})
+        end
+        h
+      end
+
+      protected
+        def coalesce_gps_opts(gps_opts)
+          gps_opts[:elevation] ||= 0
+          gps_args = [:latitude,:longitude,:elevation].map {|k| gps_opts[k]}
+          GPSCoordinates.new(*gps_args)
+        end
+    end
+  end
+end

data/lib/dgrid/api/workspace.rb

@@ -0,0 +1,567 @@
+module Dgrid
+  module API
+    class Workspace
+      include ArgumentValidation
+      include SetMembersFromHash
+
+      attr_accessor :id, :name, :description, :connection
+
+      argument :connection, Dgrid::API::Connection
+      argument :name, String
+      argument :description, String
+      def initialize(connection, name='DEFAULT WORKSPACE', description = "")
+        @id = nil
+        @connection = connection
+        @name = name
+        @item_ids = {} # lens_id => [item_id]
+        @entity_cache = Cache.new
+      end
+
+      def self.pluralized
+        'workspaces'
+      end
+      
+      def self.singular
+        name.split('::').last.downcase
+      end
+
+      def type
+        self.class.name.split('::').last
+      end
+      
+      argument :person, Dgrid::API::Person
+      def add_person(person)
+        add_entity(person)
+      end
+
+      argument :place, Dgrid::API::Place
+      def add_place(place)
+        add_entity(place)
+      end
+
+      argument :organization, Dgrid::API::Organization
+      def add_organization(organization)
+        add_entity(organization)
+      end
+
+      argument :item, Dgrid::API::Item
+      def add_item(item)
+        add_entity(item)
+      end
+
+      argument :incident, Dgrid::API::Incident
+      argument :item, Dgrid::API::Item
+      def add_incident(incident, item = nil)
+        if item
+          raise "Cannot add an Incident in a Workspace unless owning Item is already in the Workspace" unless item.in_workspace?(self)
+          raise "Cannot add an Incident to an unsaved Item" if item.new_record?
+        end
+        if incident.new_record?
+          incident = connection.create_entity(incident, self.id)
+        end
+        if !incident.in_workspace?(self)
+          incident.add_workspace(self)
+        end
+        if item
+          connection.subordinate_entity_to_other_entity_in_workspace(incident, item, self.id)
+        end
+        incident
+      end
+
+      argument :keyword, Dgrid::API::Keyword
+      def add_keyword(keyword)
+        add_entity(keyword)
+      end
+
+      def subordinate_entity_to_other_entity(entity, other)
+        connection.subordinate_entity_to_other_entity_in_workspace(entity, other, self.id)
+        @entity_cache.invalidate(Link)
+      end
+
+      #============
+
+      # TODO auto-generate this templatesque bullshit
+      def create_person(options = {})
+        person = add_person(Dgrid::API::Person.new(options))
+        person
+      end
+
+      def create_place(options = {})
+        place = add_place(Dgrid::API::Place.new(options))
+        place
+      end
+
+      def create_organization(options = {}, &block)
+        organization = add_organization(Dgrid::API::Organization.new(options))
+        yield organization if block_given?
+        organization
+      end
+
+      def create_item(options = {}, &block)
+        item = add_item(Dgrid::API::Item.new(options))
+        yield item if block_given?
+        item
+      end
+
+      argument :left_entity, Dgrid::API::Entity
+      argument :right_entity, Dgrid::API::Entity
+      option :link_type, String, :required
+      def link(left_entity, right_entity, options = {})
+        raise "Entity #{left_entity.to_s} is not in this workspace" unless left_entity.in_workspace?(self)
+        raise "Entity #{right_entity.to_s} is not in this workspace" unless right_entity.in_workspace?(self)
+        connection.create_link(left_entity, right_entity, self.id, options)
+        @entity_cache.invalidate(Link)
+      end
+
+
+      #============
+
+      def items
+          get_entities(Item)
+      end
+      def people
+          get_entities(Person)
+      end
+      def places
+          get_entities(Place)
+      end
+
+      def organizations
+          get_entities(Organization)
+      end
+
+      def links
+        get_entities(Link)
+      end
+
+      def lenses
+        get_entities(Lens)
+      end
+
+      def incidents
+        get_entities(Incident)
+      end
+
+      def keywords
+        get_entities(Keyword)
+      end
+
+      argument :lens, Dgrid::API::Lens
+      def item_ids_in_lens(lens)
+        item_ids = connection.get_items_in_lens(self.id, lens.id)
+      end
+
+      argument :lens, Dgrid::API::Item
+      def incident_ids_in_item(item)
+        incident_ids = connection.get_incidents_in_item(self.id, item.id)
+      end
+
+      def add_entity(entity)
+        if entity.new_record?
+          entity = connection.create_entity(entity,self.id)
+        end
+        if !entity.in_workspace?(self)
+          entity.add_workspace(self)
+        end
+        @entity_cache.invalidate(entity.class)
+        entity
+      end
+
+      def get_entities(klass)
+        pluralized_name = klass.pluralized
+        return @entity_cache.get(klass) if @entity_cache.include?(klass)
+        construction_fields = klass.db_fields
+        entities_params = connection.get_in_workspace(self.id, pluralized_name)
+        entities = []
+        entities_params.each do |entity_params|
+          construction_params, other_params = split_hash(entity_params, construction_fields)
+          entity = klass.new(change_string_keys_to_symbol_keys(construction_params))
+          entity.add_workspace(self)
+          entities <<  entity
+        end
+        @entity_cache.store(klass,entities)
+      end
+
+      def invalidate_cache(klass)
+        @entity_cache.invalidate(klass)
+      end
+
+      class Backup 
+        include SetMembersFromHash
+
+        def initialize(workspace = nil)
+          raise "Backup is a pure virtual class.  Use Backup.create instead of Backup.new" unless self.class != Backup
+          hashify_all_members(workspace) unless workspace.nil?
+        end
+
+        def self.current_valid_backup_class
+          # Backup_0_1
+          Backup_0_2
+        end
+
+        def current_valid_backup_class
+          self.class.current_valid_backup_class
+        end
+
+        def self.create(workspace)
+          self.current_valid_backup_class.new(workspace)
+        end
+
+        def self.entity_classes 
+          raise "Pure Virtual self.entity_classes needs to be overridden in #{self.class.name}"
+        end
+
+        def entity_classes
+          self.class.entity_classes
+        end
+
+        def self.backed_up_classes
+          self.entity_classes
+        end
+
+        def backed_up_classes
+          self.class.backed_up_classes
+        end
+
+        def restore_into(workspace)
+          if self.class == current_valid_backup_class
+            do_restore(workspace)
+          else
+            restorable_backup = current_valid_backup_class.migrate(self)
+            restorable_backup.restore_into(workspace)
+          end
+        end
+
+        def self.migrate(backup_of_wrong_class)
+          raise "Cannot migrate anything to class #{self.name}" unless self.predecessor
+          backup_of_predecessor_class = (backup_of_wrong_class.class == self.predecessor) ? backup_of_wrong_class : self.predecessor.migrate(backup_of_wrong_class)
+          migrated = self.new
+          migrated.migrate_from_predecessor(backup_of_predecessor_class)
+          migrated
+        end
+
+        def migrate_from_predecessor(predecessor)
+          raise "Pure Virtual migrate_from_predecessor needs to be overridden in #{self.class.name}"
+        end
+
+
+        protected
+          def self.predecessor
+              raise "Pure Virtual self.predecessor needs to be overridden in #{self.class.name}"
+          end
+
+          def do_restore(workspace)
+              raise "Pure Virtual do_restore needs to be overridden in #{self.class.name}"
+          end
+
+          def set_entities(klass, obj_list)
+            raise "argumet_error: expected array of #{klass.name}" unless obj_list.is_a?(Array) && (obj_list.empty? || obj_list.first.is_a?(klass))
+              set_entities_hash(klass,hashify_obj_list(obj_list))
+          end
+
+          def get_entities_hash(klass)
+            raise "invalid member type #{type}" unless backed_up_classes.include?(klass)
+            @members[klass.pluralized]
+          end
+
+          def set_entities_hash(klass,h)
+            raise "invalid member type #{type}" unless backed_up_classes.include?(klass)
+            raise "invalid hash #{h}" unless h.is_a?(Hash) && h.values.all? {|v| v.is_a?(Hash)}
+            @members[klass.pluralized] = h
+          end
+
+          def lensings(lens_id)
+            @members['lensings'][lens_id]
+          end
+
+          def set_lensings(lens_id,item_ids)
+            @members['lensings'][lens_id] = item_ids
+          end
+
+          def hashify_obj_list(obj_list)
+            result = {}
+            obj_list.each do |obj|
+              result[obj.id] = obj.to_hash
+            end
+            result
+          end
+
+        private
+          def hashify_all_members(workspace)
+              raise "Pure Virtual hashify_all_members needs to be overridden in #{self.class.name}"
+          end
+
+      end
+
+      # ==============
+      #
+      class Backup_0_1 < Backup
+
+        def self.entity_classes 
+          @@entity_classes ||= Set.new(
+            [Item,
+             Person,
+             Place,
+             Organization,
+             Link,
+             Lens,
+            ])
+        end
+
+        def self.backed_up_classes
+          self.entity_classes + [ Incident]
+        end
+
+        protected
+          def self.predecessor
+            nil
+          end
+
+          def do_restore(workspace)
+            @new_entities = {}
+            restore_entities_into(workspace)
+            restore_weird_special_cases_into(workspace)
+            restore_lenses_into(workspace)
+            restore_links_into(workspace)
+          end
+
+          def incidents_are_entities?
+            if @incidents_are_entities.nil?
+              @incidents_are_entities = entity_classes.include?(Incident)
+            end
+            return @incidents_are_entities
+          end
+
+        private
+
+          def incidents(item_id)
+            raise "The method incidents(item_id) is invalid in class #{self.class.name}" if incidents_are_entities?
+            @members[Incident.pluralized][item_id]
+          end
+
+          def set_incidents(item_id,incidents)
+            raise "The method set_incidents(item_id,incidents) is invalid in class #{self.class.name}" if incidents_are_entities?
+            raise "argument_error: expected String id" unless item_id.is_a?(String)
+            raise "argumet_error: expected array of Incident" unless incidents.is_a?(Array) && (incidents.empty? || incidents.first.is_a?(Dgrid::API::Incident))
+            @members[Incident.pluralized][item_id] = hashify_obj_list(incidents)
+          end
+
+          def hashify_all_members(workspace)
+            @members = {'lensings'=>{}}
+            @members[Incident.pluralized] = {} unless incidents_are_entities?
+            hashify_entities(workspace)
+            if !workspace.nil?
+              hashify_incidents(workspace) unless incidents_are_entities?
+              hashify_lensings(workspace)
+            end
+          end
+
+          def hashify_entities(workspace)
+            backed_up_classes.each do |klass|
+              if !get_entities_hash(klass)
+                set_entities(klass, workspace.nil? ? nil : workspace.send(klass.pluralized))
+              end
+            end
+          end
+
+          def hashify_incidents(workspace)
+            workspace.items.each do |item|
+              set_incidents(item.id,item.incidents)
+            end
+          end
+
+          def hashify_lensings(workspace)
+            workspace.lenses.each do |lens|
+              set_lensings(lens.id,lens.item_ids)
+            end
+          end
+
+          def restore_entities_into(workspace)
+            entity_classes.each do |entity_class|
+              next if entity_class.type == 'Link'
+              entity_hash = get_entities_hash(entity_class)
+              entity_hash.each do |old_id, entity_params|
+                new_entity = workspace.add_entity(entity_class.new(change_string_keys_to_symbol_keys(entity_params)))
+                entity_key =[entity_class.type,old_id]
+                @new_entities[entity_key] = new_entity
+              end
+            end
+          end
+
+          def restore_lenses_into(workspace)
+            get_entities_hash(Lens).each_pair do |old_lens_id, old_lens_params|
+              lens_key = [Lens.type, old_lens_id]
+              new_lens = @new_entities[lens_key]
+              raise "lens #{lens_key.inspect} not found in #{@new_entities.inspect}" unless new_lens
+
+              lensings(old_lens_id).each do |old_item_id|
+                item_key = [Item.type, old_item_id]
+                new_item = @new_entities[item_key]
+                raise "item #{item_key.inspect} not found in #{@new_entities.inspect}" unless new_item
+                new_lens.add_item(new_item)
+              end
+            end
+          end
+
+          def restore_links_into(workspace)
+            get_entities_hash(Link).each_pair do |old_link_id, old_link_params|
+              left_type = old_link_params[:left_type]
+              right_type = old_link_params[:right_type]
+              left_guid = old_link_params[:left_guid]
+              right_guid = old_link_params[:right_guid]
+              # Incident to Item links are covered during incident creation so we can skip those
+              new_left = @new_entities[[left_type,left_guid]]
+              new_right = @new_entities[[right_type,right_guid]]
+              if left_type == 'Incident' && right_type == 'Item' 
+                if incidents_are_entities?
+                  workspace.subordinate_entity_to_other_entity(new_left,new_right)
+                end
+                next
+              end
+              if right_type == 'Incident' && left_type == 'Item' 
+                if incidents_are_entities?
+                  workspace.subordinate_entity_to_other_entity(new_right,new_left)
+                end
+                next
+              end
+
+              STDERR.puts "Warning:  Dangling link #{old_link_id}: #{old_link_params}" unless new_left && new_right
+              if new_left.is_a?(Dgrid::API::Incident) || (new_left.is_a?(Dgrid::API::Organization) && new_right.is_a?(Dgrid::API::Person))
+                workspace.subordinate_entity_to_other_entity(new_right,new_left)
+              elsif new_right.is_a?(Dgrid::API::Incident) || (new_right.is_a?(Dgrid::API::Organization) && new_left.is_a?(Dgrid::API::Person))
+                workspace.subordinate_entity_to_other_entity(new_left,new_right)
+              else
+                workspace.link(new_left,new_right, old_link_params[:description])
+              end
+            end
+          end
+
+          def restore_weird_special_cases_into(workspace)
+            get_entities_hash(Item).each_pair do |old_item_id, old_item_params|
+              item_key = [Item.type, old_item_id]
+              new_item = @new_entities[item_key]
+              raise "item #{item_key.inspect} not found in #{@new_entities.inspect}" unless new_item
+              incidents(old_item_id).each_pair do |old_incident_id, old_incident_params|
+                new_incident = workspace.add_incident(Incident.new(change_string_keys_to_symbol_keys(old_incident_params)), new_item)
+                incident_key =[Incident.type,old_incident_id]
+                @new_entities[incident_key]  = new_incident
+              end
+            end
+          end
+
+      end # of class Backup_0_1
+
+      # ==============
+      #
+      class Backup_0_2 < Backup_0_1
+
+        def self.entity_classes 
+          # This is the only real difference between versions 0_1 and 0_2
+          # Incident promoted to base-level entity and Keywords added.
+          @@entity_classes ||= predecessor.entity_classes + [Incident, Keyword]
+        end
+
+        def self.backed_up_classes
+          self.entity_classes
+        end
+
+        def migrate_from_predecessor(predecessor)
+          pred_entity_classes = Set.new(predecessor.class.entity_classes)
+          self.class.entity_classes.each do |entity_class|
+            if pred_entity_classes.include?(entity_class)
+              pred_entities = predecessor.get_entities_hash(entity_class)
+              set_entities_hash(my_entity_class,pred_entities.clone)
+            end
+          end
+          if self.incidents_are_entities? && !pred_entity_classes.include?(Incident)
+            migrate_item_subord_incidents_to_entity_incidents(predecessor)
+          end
+        end
+
+
+        protected
+
+          def self.predecessor
+            Backup_0_1
+          end
+
+        private
+          def restore_weird_special_cases_into(workspace)
+            # nothing to do, just overriding predecessor's implementation
+          end
+
+          def migrate_item_subord_incidents_to_entity_incidents(predecessor)
+            pred_item_ids = predecessor.get_entities_hash(Item).keys
+            incidents_hash = {}
+            links_hash = get_entities_hash(Link)
+            pred_item_ids.each do |item_id|
+              item_incidents = incidents(item_id)
+              item_incidents.each_pair do |incident_id,incident_params|
+                incidents_hash[incident_id] = incident_params
+                ensure_links_include_item_incident(links_hash, item_id,incident_id)
+              end
+            end
+          end
+
+          def ensure_links_include_item_incident(links_hash,item_id,incident_id)
+            if !links_include_relationship_between(links_hash,Item,item_id,Incident,incident_id)
+              new_link_id = generate_new_link_id
+              links_hash[new_link_id] = {
+                :left_type => Item.name,
+                :left_guid => item_id,
+                :right_type => Incident.guid,
+                :right_id => incident_id,
+                :description => 'item-incident'
+              }
+            end
+          end
+          def links_include_relationship_between(links_hash,type1,guid1,type2,guid2)
+              links_hash.values.any? { |link| 
+                  (link[:left_type] == type1 && link[:left_guid] == guid1 &&
+                   link[:right_type] == type2 && link[:right_guid] == guid2) ||
+                  (link[:right_type] == type1 && link[:right_guid] == guid1 &&
+                   link[:left_type] == type2 && link[:left_guid] == guid2)
+              }
+          end
+      end # of class Backup_0_2
+
+      def backup()
+        backup = Backup.create(self)
+      end
+
+      argument :connection, Dgrid::API::Workspace
+      def clone_members_into(other_workspace)
+        backup().restore_into(other_workspace)
+      end
+
+
+      protected
+        class Cache
+          def initialize
+            @entries = {}
+          end
+
+          def include?(type)
+            @entries.include?(type)
+          end
+
+          def store(type,value)
+            @entries[type] = value
+          end
+
+          def get(type)
+            @entries[type]
+          end
+
+          def invalidate(type = nil)
+            if type.nil?
+              @entries = {}
+            else
+              @entries.delete(type)
+            end
+          end
+        end # class Cache
+
+    end
+  end
+end