Remove Link

app_spec/test/test.js

@@ -79,27 +79,44 @@ scenario1.runTape('create_post', async (t, { alice }) => {
   t.equal(result.Ok, "QmY6MfiuhHnQ1kg7RwNZJNUQhwDxTFL45AAPnpJMNPEoxk")
 })
 
+scenario2.runTape('delete_post', async (t, { alice, bob }) => {
 
-scenario1.runTape('delete_post', async (t, { alice }) => {
-  t.plan(3)
-
-  const content = "Hello Holo world 321"
-  const in_reply_to = null
-  const params = { content, in_reply_to }
-  const createResult = alice.call("blog", "create_post", params)
-
-  t.ok(createResult.Ok)
-
-  const deletionParams = { post_address: createResult.Ok }
-  const deletionResult = alice.call("blog", "delete_post", deletionParams)
-
-  t.equals(deletionResult.Ok, null)
-
-  const paramsGet = { post_address: createResult.Ok }
-  const result = alice.call("blog", "get_post", paramsGet)
-
-  t.equals(result.Ok, null)
-})
+  await alice.callSync("blog", "create_post",
+    { "content": "Posty", "in_reply_to": "" }
+  )
+  const result_create_post = alice.call("blog", "my_posts", {})
+  t.equal(result_create_post.Ok.addresses.length, 1)
+  await alice.callSync("blog", "delete_post",
+    { "content": "Posty"}
+  )
+  const result_delete_post = alice.call("blog", "my_posts", {})
+  t.equal(result_delete_post.Ok.addresses.length, 0)
+
+  const result_delete_post_bob = bob.call("blog", "my_posts", {})
+  t.equal(result_delete_post_bob.Ok.addresses.length, 0)
+
+  })
+
+  scenario1.runTape('delete_entry_post', async (t, { alice }) => {
+    t.plan(3)
+
+    const content = "Hello Holo world 321"
+    const in_reply_to = null
+    const params = { content, in_reply_to }
+    const createResult = alice.call("blog", "create_post", params)
+
+    t.ok(createResult.Ok)
+
+    const deletionParams = { post_address: createResult.Ok }
+    const deletionResult = alice.call("blog", "delete_entry_post", deletionParams)
+
+    t.equals(deletionResult.Ok, null)
+
+    const paramsGet = { post_address: createResult.Ok }
+    const result = alice.call("blog", "get_post", paramsGet)
+
+    t.equals(result.Ok, null)
+  })
 
 scenario1.runTape('update_post', async (t, { alice }) => {
   t.plan(4)
@@ -123,7 +140,7 @@ scenario1.runTape('update_post', async (t, { alice }) => {
   t.deepEqual(JSON.parse(updatedPost.Ok.App[1]), { content: "Hello Holo", date_created: "now" })
 })
 
-scenario1.runTape('create_post with bad reply to', async (t, { alice }) => {
+ scenario1.runTape('create_post with bad reply to', async (t, { alice }) => {
   t.plan(5)
 
   const content = "Holo world"

app_spec/zomes/blog/code/src/blog.rs

@@ -100,6 +100,13 @@ pub fn handle_create_post(content: String, in_reply_to: Option<Address>) -> Zome
     Ok(address)
 }
 
+pub fn handle_delete_post(content:String) -> ZomeApiResult<Address>
+{
+    let address = hdk::entry_address(&post_entry(content))?;
+    hdk::remove_link(&AGENT_ADDRESS,&address.clone(),"authored_posts")?;
+    Ok(address)
+}
+
 pub fn handle_posts_by_agent(agent: Address) -> ZomeApiResult<GetLinksResult> {
     hdk::get_links(&agent, "authored_posts")
 }
@@ -137,7 +144,7 @@ pub fn handle_get_post(post_address: Address) -> ZomeApiResult<Option<Entry>> {
     hdk::get_entry(&post_address)
 }
 
-pub fn handle_delete_post(post_address: Address) -> ZomeApiResult<()> {
+pub fn handle_entry_delete_post(post_address: Address) -> ZomeApiResult<()> {
     hdk::get_entry(&post_address)?;
 
     hdk::remove_entry(&post_address)?;

app_spec/zomes/blog/code/src/lib.rs

@@ -66,9 +66,15 @@ define_zome! {
         }
 
         delete_post: {
+            inputs: |content: String|,
+            outputs: |result: ZomeApiResult<Address>|,
+            handler: blog::handle_delete_post
+        }
+
+        delete_entry_post: {
             inputs: |post_address: Address|,
             outputs: |result: ZomeApiResult<()>|,
-            handler: blog::handle_delete_post
+            handler: blog::handle_entry_delete_post
         }
 
         update_post: {

cas_implementations/src/eav/file.rs

@@ -193,22 +193,44 @@ impl EntityAttributeValueStorage for EavFileStorage {
         index_query: IndexQuery,
     ) -> Result<BTreeSet<EntityAttributeValueIndex>, HolochainError> {
         let _guard = self.lock.read()?;
-        let entity_set = self.read_from_dir::<Entity>(ENTITY_DIR.to_string(), entity.clone())?;
-        let attribute_set = self
-            .read_from_dir::<Attribute>(ATTRIBUTE_DIR.to_string(), attribute)?
-            .clone();
-        let value_set = self.read_from_dir::<Value>(VALUE_DIR.to_string(), value)?;
-
-        let attribute_value_inter: BTreeSet<String> = value_set
-            .intersection(&attribute_set.clone())
-            .cloned()
-            .collect();
-        let entity_attribute_value_inter: BTreeSet<String> = attribute_value_inter
-            .intersection(&entity_set)
-            .cloned()
-            .collect();
-
-        let (eav, error): (BTreeSet<_>, BTreeSet<_>) = entity_attribute_value_inter
+        let prefixes = if !index_query.prefixes().is_empty() {
+            index_query.prefixes().clone()
+        } else {
+            vec![""]
+        };
+        let union_set: BTreeSet<String> = BTreeSet::new();
+        let entity_attribute_value_union = prefixes.iter().fold(
+            Ok(union_set.clone()),
+            |set: Result<BTreeSet<String>, HolochainError>, prefix: &&str| {
+                let entity_set =
+                    self.read_from_dir::<Entity>(ENTITY_DIR.to_string(), entity.clone())?;
+                let attribute_with_prefix = attribute
+                    .clone()
+                    .map(|attri| prefix.to_string() + &attri.clone());
+                let attribute_set = self
+                    .read_from_dir::<Attribute>(ATTRIBUTE_DIR.to_string(), attribute_with_prefix)
+                    .clone()?;
+                let value_set =
+                    self.read_from_dir::<Value>(VALUE_DIR.to_string(), value.clone())?;
+
+                let attribute_value_inter: BTreeSet<String> = value_set
+                    .intersection(&attribute_set.clone())
+                    .cloned()
+                    .collect();
+                let entity_attribute_value_inter: BTreeSet<String> = attribute_value_inter
+                    .intersection(&entity_set)
+                    .cloned()
+                    .collect();
+                let to_union = set?;
+                Ok(to_union
+                    .union(&entity_attribute_value_inter)
+                    .cloned()
+                    .collect())
+            },
+        );
+
+        let (eav, error): (BTreeSet<_>, BTreeSet<_>) = entity_attribute_value_union?
+            .clone()
             .into_iter()
             .map(|content| EntityAttributeValueIndex::try_from_content(&JsonString::from(content)))
             .partition(|c| c.is_ok());
@@ -232,7 +254,7 @@ impl EntityAttributeValueStorage for EavFileStorage {
                         .start()
                         .map(|start| start <= e.index())
                         .unwrap_or_else(|| {
-                            let latest = get_latest(e.clone(), map.clone())
+                            let latest = get_latest(e.clone(), map.clone(), index_query.clone())
                                 .unwrap_or(EntityAttributeValueIndex::default());
                             latest.index() == e.index()
                         })
@@ -242,7 +264,7 @@ impl EntityAttributeValueStorage for EavFileStorage {
                         .end()
                         .map(|end| end >= e.index())
                         .unwrap_or_else(|| {
-                            let latest = get_latest(e.clone(), map.clone())
+                            let latest = get_latest(e.clone(), map.clone(), index_query.clone())
                                 .unwrap_or(EntityAttributeValueIndex::default());
                             latest.index() == e.index()
                         })

cas_implementations/src/eav/memory.rs

@@ -57,15 +57,19 @@ impl EntityAttributeValueStorage for EavMemoryStorage {
             .into_iter()
             .filter(|e| EntityAttributeValueIndex::filter_on_eav(&e.entity(), entity.as_ref()))
             .filter(|e| {
-                EntityAttributeValueIndex::filter_on_eav(&e.attribute(), attribute.as_ref())
+                EntityAttributeValueIndex::filter_on_eav_with_prefix(
+                    &e.attribute(),
+                    attribute.as_ref(),
+                    &index_query,
+                )
             })
             .filter(|e| EntityAttributeValueIndex::filter_on_eav(&e.value(), value.as_ref()))
             .filter(|e| {
                 index_query
                     .start()
                     .map(|start| start <= e.index())
                     .unwrap_or_else(|| {
-                        let latest = get_latest(e.clone(), map.clone())
+                        let latest = get_latest(e.clone(), map.clone(), index_query.clone())
                             .unwrap_or(EntityAttributeValueIndex::default());
                         latest.index() == e.index()
                     })
@@ -75,7 +79,7 @@ impl EntityAttributeValueStorage for EavMemoryStorage {
                     .end()
                     .map(|end| end >= e.index())
                     .unwrap_or_else(|| {
-                        let latest = get_latest(e.clone(), map.clone())
+                        let latest = get_latest(e.clone(), map.clone(), index_query.clone())
                             .unwrap_or(EntityAttributeValueIndex::default());
                         latest.index() == e.index()
                     })

core/src/action.rs

@@ -100,6 +100,9 @@ pub enum Action {
     /// Does not validate, assumes link is valid.
     AddLink(Link),
 
+    //Removes a link for the local DHT
+    RemoveLink(Link),
+
     // ----------------
     // Network actions:
     // ----------------

core/src/dht/actions/mod.rs

@@ -1,3 +1,4 @@
 pub mod add_link;
 pub mod hold;
 pub mod remove_entry;
+pub mod remove_link;

core/src/dht/actions/remove_link.rs

@@ -0,0 +1,59 @@
+extern crate futures;
+extern crate serde_json;
+use crate::{
+    action::{Action, ActionWrapper},
+    context::Context,
+    instance::dispatch_action,
+};
+use futures::{
+    future::Future,
+    task::{LocalWaker, Poll},
+};
+use holochain_core_types::{error::HolochainError, link::Link};
+use std::{pin::Pin, sync::Arc};
+
+/// RemoveLink Action Creator
+/// This action creator dispatches an RemoveLink action which is consumed by the DHT reducer.
+/// Note that this function does not include any validation checks for the link.
+/// The DHT reducer does make sure that it only removes links to a base that it has in its
+/// local storage and will return an error that the RemoveLinkFuture resolves to
+/// if that is not the case.
+///
+/// Returns a future that resolves to an Ok(()) or an Err(HolochainError).
+pub fn remove_link(link: &Link, context: &Arc<Context>) -> RemoveLinkFuture {
+    let action_wrapper = ActionWrapper::new(Action::RemoveLink(link.clone()));
+    dispatch_action(context.action_channel(), action_wrapper.clone());
+
+    RemoveLinkFuture {
+        context: context.clone(),
+        action: action_wrapper,
+    }
+}
+
+pub struct RemoveLinkFuture {
+    context: Arc<Context>,
+    action: ActionWrapper,
+}
+
+impl Unpin for RemoveLinkFuture {}
+
+impl Future for RemoveLinkFuture {
+    type Output = Result<(), HolochainError>;
+
+    fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {
+        //
+        // TODO: connect the waker to state updates for performance reasons
+        // See: https://github.com/holochain/holochain-rust/issues/314
+        //
+        lw.wake();
+        if let Some(state) = self.context.state() {
+            match state.dht().actions().get(&self.action) {
+                Some(Ok(_)) => Poll::Ready(Ok(())),
+                Some(Err(e)) => Poll::Ready(Err(e.clone())),
+                None => Poll::Pending,
+            }
+        } else {
+            Poll::Pending
+        }
+    }
+}