Node template folders restructuring (#4811)

* Restructure node-template so it is clear that node, runtime, and pallets are separated
* Separating to mock and tests
* restructuring runtime to top-level
* updated release script
* updated Cargo.lock

substrate/bin/node-template/pallets/template/src/lib.rs

@@ -0,0 +1,104 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// A runtime module template with necessary imports
+
+/// Feel free to remove or edit this file as needed.
+/// If you change the name of this file, make sure to update its references in runtime/src/lib.rs
+/// If you remove this file, you can remove those references
+
+/// For more guidance on Substrate modules, see the example module
+/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs
+
+use frame_support::{decl_module, decl_storage, decl_event, decl_error, dispatch};
+use system::ensure_signed;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+/// The pallet's configuration trait.
+pub trait Trait: system::Trait {
+	// Add other types and constants required to configure this pallet.
+
+	/// The overarching event type.
+	type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
+}
+
+// This pallet's storage items.
+decl_storage! {
+	trait Store for Module<T: Trait> as TemplateModule {
+		// Just a dummy storage item.
+		// Here we are declaring a StorageValue, `Something` as a Option<u32>
+		// `get(fn something)` is the default getter which returns either the stored `u32` or `None` if nothing stored
+		Something get(fn something): Option<u32>;
+	}
+}
+
+// The pallet's events
+decl_event!(
+	pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {
+		/// Just a dummy event.
+		/// Event `Something` is declared with a parameter of the type `u32` and `AccountId`
+		/// To emit this event, we call the deposit funtion, from our runtime funtions
+		SomethingStored(u32, AccountId),
+	}
+);
+
+// The pallet's errors
+decl_error! {
+	pub enum Error for Module<T: Trait> {
+		/// Value was None
+		NoneValue,
+		/// Value reached maximum and cannot be incremented further
+		StorageOverflow,
+	}
+}
+
+// The pallet's dispatchable functions.
+decl_module! {
+	/// The module declaration.
+	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+		// Initializing errors
+		// this includes information about your errors in the node's metadata.
+		// it is needed only if you are using errors in your pallet
+		type Error = Error<T>;
+
+		// Initializing events
+		// this is needed only if you are using events in your pallet
+		fn deposit_event() = default;
+
+		/// Just a dummy entry point.
+		/// function that can be called by the external world as an extrinsics call
+		/// takes a parameter of the type `AccountId`, stores it, and emits an event
+		pub fn do_something(origin, something: u32) -> dispatch::DispatchResult {
+			// Check it was signed and get the signer. See also: ensure_root and ensure_none
+			let who = ensure_signed(origin)?;
+
+			// Code to execute when something calls this.
+			// For example: the following line stores the passed in u32 in the storage
+			Something::put(something);
+
+			// Here we are raising the Something event
+			Self::deposit_event(RawEvent::SomethingStored(something, who));
+			Ok(())
+		}
+
+		/// Another dummy entry point.
+		/// takes no parameters, attempts to increment storage value, and possibly throws an error
+		pub fn cause_error(origin) -> dispatch::DispatchResult {
+			// Check it was signed and get the signer. See also: ensure_root and ensure_none
+			let _who = ensure_signed(origin)?;
+
+			match Something::get() {
+				None => Err(Error::<T>::NoneValue)?,
+				Some(old) => {
+					let new = old.checked_add(1).ok_or(Error::<T>::StorageOverflow)?;
+					Something::put(new);
+					Ok(())
+				},
+			}
+		}
+	}
+}