class User
Represents a user. Most of the User's logic is controlled by Devise and its overrides. A user, as far as the application code (i.e. excluding Devise) is concerned, has many questions, answers, and votes.
Public Instance Methods
Creates and adds a notification to the instance user's notification stack.
# File app/models/user.rb, line 41 def create_notification(content, link) notification = Notification.create(content: content, link: link) notifications << notification end
Basically the same as User#has_privilege?
, but checks
privileges with relation to the post as well. OPs always have every
privilege on their own posts.
# File app/models/user.rb, line 32 def has_post_privilege?(name, post) if post.user == self return true else return self.has_privilege?(name) end end
Checks whether or not a user has the given privilege. For efficiency,
initially checks if the privilege is in the user's
privileges
association and returns true if so; otherwise
checks reputation and assigns the privilege if the user has enough rep.
This method should not be used to secure administrator-only privileges, as
both admins and mods are assumed to have the privilege.
# File app/models/user.rb, line 18 def has_privilege?(name) privilege = Privilege.where(:name => name).first if privileges.include?(privilege) || is_admin || is_moderator return true elsif privilege && reputation >= privilege.threshold privileges << privilege return true else return false end end
Returns a count of unread notifications for the instance user. Does not
return the notifications themselves; that should be done by calling the API
action from NotificationsController#index
.
# File app/models/user.rb, line 48 def unread_notifications return notifications.where(:is_read => false).count end


Take over control before loading the Operating system.
EFIDroid attempts to make it easy for both users and developers to control their boot experience.
Multiboot
Install and boot any number of operating systems and recovery tools.
Boot plugins
Change the boot behavior without modifying ROM's. Swapping internal/external memory, overclocking or modifying the ramdisk. Live and without any permanent modifications.
UEFI Apps
EFIDroid uses UEFI in the background which means that you can boot other bootloaders like GRUB or rEFInd and even small games :)


Don't you forget about the query params
start=Y-m-d&end=Y-m-d
Code Reviews por Commenter
Pull Request Por Author


I'm a full-stack developer passionate about solving problems. I love to see ideas turning into usable and valuable software and, for me, being a full-stack developer is the best way to achieve that. In the past few years I've been involved in different projects that share something in common: they're all trying to solve problems in the world to make people's lives better.
I think that technology can bring great things to our society and it's my generation's duty to make sure that all the technology being created is used for improving our lives.
One thing that I found out about myself recently is that I love to teach. It brings me so much joy when I'm able to speak about something that I know and somehow I inspire other people. I believe that the main path for developing technology that improves our society is through education. That's why I'm willing to make teaching another part of my professional career.


This is an example webpage to develop and test Skip Silence.
Video used: https://www.youtube.com/watch?v=xWsD6a3KsAI


We're sorry but Huashenghaoche doesn't work properly without JavaScript enabled. Please enable it to continue.


DBC week 1: Technical blog
Benefits of version control and how Git & Github works?
Established on Dec. 6, 2015
"What the hack are version control, Git and GitHub?" I screamed. As a person who is new to the programming world these technical terms seems strange. But now I am at DBC and my objective is to get to know them! VERY WELL! Let's me try to briefly explain what are these monsters really are!
So lets assume you are on a new project. And it consists of tens of hundreds of files or documents. You want to be organized. So you placed all files in one place so you know where to work on. As time goes on, you made changes here and there all over those tens of hundreds of files. Kind of a mess to keep track of changes and there may be a potential risk you have to start all over again because you made a terrible mistake. You might ask yourself, why can't real life gives you a save button at some state? Well.. here is the version control system comes to rescue your project. Version control system keeps track of users files and records all changes made over time. It allows user to jump back and forth or navigate to specific record/versions.
As you can guess, Git is a free and open source distributed version control system that users install locally to handle projects with different “versions” of your work as you proceed and managed by users via adds and commits command lines.
What about Github? Is it a version control system as well? Counterintuitively, No. Git is not Github. Github provides hosting services for users to store their projects/repositories and allowing multiple users to work collaboratively on the same project at the same time remotely by using git as its version control system. Why is it good to store your projects on Github? Because not only you can have your colleague review your code anytime and anywhere, but you can also sync with your colleague no matter what updates and merges occur. Aren't they just awesome?


Module: RubyTerraform::ClassMethods
- Included in:
- RubyTerraform
- Defined in:
- lib/ruby_terraform.rb
Overview
rubocop:disable Metrics/ModuleLength
Instance Method Summary collapse
-
#apply(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform apply command which creates or updates infrastructure according to terraform configuration files in the provided directory.
-
#destroy(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform destroy command which destroys terraform managed infrastructure.
-
#force_unlock(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform force-unlock command which manually unlocks the state for the defined configuration.
-
#format(parameters = {}, invocation_options = {}) ⇒ Object
(also: #fmt)
Invokes the terraform fmt command which rewrites all terraform configuration files to a canonical format.
-
#get(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform get command which downloads and installs modules needed for the given configuration.
-
#graph(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform graph command which outputs the visual execution graph of terraform resources according to either the current configuration or an execution plan.
-
#import(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform import command which imports existing infrastructure into your terraform state.
-
#init(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform init command which initializes a new or existing Terraform working directory by creating initial files, loading any remote state, downloading modules, etc.
-
#login(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform login command which retrieves an authentication token for the given hostname, if it supports automatic login, and saves it in a credentials file in your home directory.
-
#logout(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform logout command which removes locally-stored credentials for specified hostname.
-
#output(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform output command which reads an output variable from a Terraform state file and prints the value.
-
#plan(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform plan command which generates a speculative execution plan, showing what actions Terraform would take to apply the current configuration.
-
#providers(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers command which prints out a tree of modules in the referenced configuration annotated with their provider requirements.
-
#providers_lock(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers lock command which writes out dependency locks for the configured providers.
-
#providers_mirror(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers mirror command which saves local copies of all required provider plugins.
-
#providers_schema(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers schema command which prints out a json representation of the schemas for all providers used in the current configuration.
-
#refresh(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform refresh command which updates the state file of your infrastructure with metadata that matches the physical resources they are tracking.
-
#show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform show command which reads and outputs a Terraform state or plan file in a human-readable form.
-
#state_list(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state list command which lists resources in the Terraform state.
-
#state_move(parameters = {}, invocation_options = {}) ⇒ Object
(also: #state_mv)
Invokes the terraform state mv command which moves an item in the state.
-
#state_pull(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state pull command which pulls the state from its location, upgrades the local copy, and outputs it to stdout.
-
#state_push(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state push command which updates remote state from a local state file.
-
#state_remove(parameters = {}, invocation_options = {}) ⇒ Object
(also: #state_rm)
Invokes the terraform state rm command which removes one or more items from the Terraform state, causing Terraform to “forget” those items without first destroying them in the remote system.
-
#state_replace_provider(parameters = {}, invocation_options = {}) ⇒ Object
Invoke the terraform state replace-provider command which replaces provider for resources in the Terraform state.
-
#state_show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state show command which shows the attributes of a resource in the Terraform state.
-
#taint(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform taint command which marks a resource instance as not fully functional.
-
#untaint(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform untaint command which removes the 'tainted' state from a resource instance.
-
#validate(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform validate command which checks whether a configuration is valid.
-
#workspace(parameters = {}, invocation_options = {}) ⇒ Object
rubocop:disable Metrics/MethodLength.
-
#workspace_delete(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace delete command which deletes a workspace.
-
#workspace_list(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace list command which lists workspaces.
-
#workspace_new(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace new command which creates a new workspace.
-
#workspace_select(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace select command which selects a workspace.
-
#workspace_show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace show command which shows the name of the current workspace.
Instance Method Details
#apply(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform apply command which creates or updates infrastructure according to terraform configuration files in the provided directory.
By default, terraform will generate a new plan and present it for approval before taking any action. Alternatively, the command accepts a plan file created by a previous invocation, in which case terraform will take the actions described in that plan without any confirmation prompt.
111 112 113 |
# File 'lib/ruby_terraform.rb', line 111 def apply(parameters = {}, = {}) exec(RubyTerraform::Commands::Apply, parameters, ) end |
#destroy(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform destroy command which destroys terraform managed infrastructure.
178 179 180 181 |
# File 'lib/ruby_terraform.rb', line 178 def destroy(parameters = {}, = {}) exec(RubyTerraform::Commands::Destroy, parameters, ) end |
#force_unlock(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform force-unlock command which manually unlocks the state for the defined configuration.
This will not modify your infrastructure. This command removes the lock on the state for the current workspace. The behavior of this lock is dependent on the backend being used. Local state files cannot be unlocked by another process.
210 211 212 213 |
# File 'lib/ruby_terraform.rb', line 210 def force_unlock(parameters = {}, = {}) exec(RubyTerraform::Commands::ForceUnlock, parameters, ) end |
#format(parameters = {}, invocation_options = {}) ⇒ Object Also known as: fmt
Invokes the terraform fmt command which rewrites all terraform configuration files to a canonical format.
Both configuration files (.tf) and variables files (.tfvars) are updated. JSON files (.tf.json or .tfvars.json) are not modified.
If :directory
is not specified in the parameters map then the current working directory will be used. If :directory
is “-” then content will be read from the standard input. The given content must be in the terraform language native syntax; JSON is not supported.
255 256 257 258 |
# File 'lib/ruby_terraform.rb', line 255 def format(parameters = {}, = {}) exec(RubyTerraform::Commands::Format, parameters, ) end |
#get(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform get command which downloads and installs modules needed for the given configuration.
This recursively downloads all modules needed, such as modules imported by the root and so on. If a module is already downloaded, it will not be redownloaded or checked for updates unless :update
is true
.
Module installation also happens automatically by default as part of the #init command, so you should rarely need to run this command separately.
292 293 294 295 |
# File 'lib/ruby_terraform.rb', line 292 def get(parameters = {}, = {}) exec(RubyTerraform::Commands::Get, parameters, ) end |
#graph(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform graph command which outputs the visual execution graph of terraform resources according to either the current configuration or an execution plan.
The graph is outputted in DOT format. The typical program that can read this format is GraphViz, but many web services are also available to read this format.
The :type
option can be used to control the type of graph shown. Terraform creates different graphs for different operations. See the options below for the list of types supported. The default type is “plan” if a configuration is given, and “apply” if a plan file is passed as an argument.
336 337 338 339 |
# File 'lib/ruby_terraform.rb', line 336 def graph(parameters = {}, = {}) exec(RubyTerraform::Commands::Graph, parameters, ) end |
#import(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform import command which imports existing infrastructure into your terraform state.
This will find and import the specified resource into your terraform state, allowing existing infrastructure to come under terraform management without having to be initially created by terraform.
The :address
specified is the address to import the resource to. Please see the documentation online for resource addresses. The :id
is a resource-specific ID to identify that resource being imported. Please reference the documentation for the resource type you're importing to determine the ID syntax to use. It typically matches directly to the ID that the provider uses.
The current implementation of terraform import can only import resources into the state. It does not generate configuration. A future version of terraform will also generate configuration.
Because of this, prior to running terraform import it is necessary to write a resource configuration block for the resource manually, to which the imported object will be attached.
This command will not modify your infrastructure, but it will make network requests to inspect parts of your infrastructure relevant to the resource being imported.
433 434 435 436 |
# File 'lib/ruby_terraform.rb', line 433 def import(parameters = {}, = {}) exec(RubyTerraform::Commands::Import, parameters, ) end |
#init(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform init command which initializes a new or existing Terraform working directory by creating initial files, loading any remote state, downloading modules, etc.
This is the first command that should be run for any new or existing Terraform configuration per machine. This sets up all the local data necessary to run Terraform that is typically not committed to version control.
This command is always safe to run multiple times. Though subsequent runs may give errors, this command will never delete your configuration or state. Even so, if you have important information, please back it up prior to running this command, just in case.
510 511 512 513 |
# File 'lib/ruby_terraform.rb', line 510 def init(parameters = {}, = {}) exec(RubyTerraform::Commands::Init, parameters, ) end |
#login(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform login command which retrieves an authentication token for the given hostname, if it supports automatic login, and saves it in a credentials file in your home directory.
If no hostname is provided, the default hostname is app.terraform.io, to log in to Terraform Cloud.
If not overridden by credentials helper settings in the CLI configuration, the credentials will be written to the following local file:
~/.terraform.d/credentials.tfrc.json
537 538 539 540 |
# File 'lib/ruby_terraform.rb', line 537 def login(parameters = {}, = {}) exec(RubyTerraform::Commands::Login, parameters, ) end |
#logout(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform logout command which removes locally-stored credentials for specified hostname.
Note: the API token is only removed from local storage, not destroyed on the remote server, so it will remain valid until manually revoked.
If no hostname is provided, the default hostname is app.terraform.io.
561 562 563 564 |
# File 'lib/ruby_terraform.rb', line 561 def logout(parameters = {}, = {}) exec(RubyTerraform::Commands::Logout, parameters, ) end |
#output(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform output command which reads an output variable from a Terraform state file and prints the value. With no additional arguments, output will display all the outputs for the root module. If :name
is not specified, all outputs are printed.
593 594 595 596 |
# File 'lib/ruby_terraform.rb', line 593 def output(parameters = {}, = {}) exec(RubyTerraform::Commands::Output, parameters, ) end |
#plan(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform plan command which generates a speculative execution plan, showing what actions Terraform would take to apply the current configuration. This command will not actually perform the planned actions.
You can optionally save the plan to a file, which you can then pass to the #read command to perform exactly the actions described in the plan.
673 674 675 |
# File 'lib/ruby_terraform.rb', line 673 def plan(parameters = {}, = {}) exec(RubyTerraform::Commands::Plan, parameters, ) end |
#providers(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers command which prints out a tree of modules in the referenced configuration annotated with their provider requirements.
This provides an overview of all of the provider requirements across all referenced modules, as an aid to understanding why particular provider plugins are needed and why particular versions are selected.
699 700 701 702 |
# File 'lib/ruby_terraform.rb', line 699 def providers(parameters = {}, = {}) exec(RubyTerraform::Commands::Providers, parameters, ) end |
#providers_lock(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers lock command which writes out dependency locks for the configured providers.
Normally the dependency lock file (.terraform.lock.hcl) is updated automatically by “terraform init”, but the information available to the normal provider installer can be constrained when you're installing providers from filesystem or network mirrors, and so the generated lock file can end up incomplete.
The “providers lock” subcommand addresses that by updating the lock file based on the official packages available in the origin registry, ignoring the currently-configured installation strategy.
After this command succeeds, the lock file will contain suitable checksums to allow installation of the providers needed by the current configuration on all of the selected platforms.
By default this command updates the lock file for every provider declared in the configuration. You can override that behavior by providing one or more provider source addresses on the command line.
774 775 776 777 |
# File 'lib/ruby_terraform.rb', line 774 def providers_lock(parameters = {}, = {}) exec(RubyTerraform::Commands::ProvidersLock, parameters, ) end |
#providers_mirror(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers mirror command which saves local copies of all required provider plugins.
Populates a local directory with copies of the provider plugins needed for the current configuration, so that the directory can be used either directly as a filesystem mirror or as the basis for a network mirror and thus obtain those providers without access to their origin registries in future.
The mirror directory will contain JSON index files that can be published along with the mirrored packages on a static HTTP file server to produce a network mirror. Those index files will be ignored if the directory is used instead as a local filesystem mirror.
820 821 822 823 |
# File 'lib/ruby_terraform.rb', line 820 def providers_mirror(parameters = {}, = {}) exec(RubyTerraform::Commands::ProvidersMirror, parameters, ) end |
#providers_schema(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform providers schema command which prints out a json representation of the schemas for all providers used in the current configuration.
841 842 843 844 |
# File 'lib/ruby_terraform.rb', line 841 def providers_schema(parameters = {}, = {}) exec(RubyTerraform::Commands::ProvidersSchema, parameters, ) end |
#refresh(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform refresh command which updates the state file of your infrastructure with metadata that matches the physical resources they are tracking.
This will not modify your infrastructure, but it can modify your state file to update metadata. This metadata might cause new changes to occur when you generate a plan or call apply next.
916 917 918 |
# File 'lib/ruby_terraform.rb', line 916 def refresh(parameters = {}, = {}) exec(RubyTerraform::Commands::Refresh, parameters, ) end |
#show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform show command which reads and outputs a Terraform state or plan file in a human-readable form. If no path is specified, the current state will be shown.
941 942 943 944 |
# File 'lib/ruby_terraform.rb', line 941 def show(parameters = {}, = {}) exec(RubyTerraform::Commands::Show, parameters, ) end |
#state_list(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state list command which lists resources in the Terraform state.
This command lists resource instances in the Terraform state. The address option can be used to filter the instances by resource or module. If no pattern is given, all resource instances are listed.
The addresses must either be module addresses or absolute resource addresses, such as:
-
aws_instance.example
-
module.example
-
module.example.module.child
-
module.example.aws_instance.example
An Errors::ExecutionError will be raised if any of the resources or modules given as filter addresses do not exist in the state.
987 988 989 990 |
# File 'lib/ruby_terraform.rb', line 987 def state_list(parameters = {}, = {}) exec(RubyTerraform::Commands::StateList, parameters, ) end |
#state_move(parameters = {}, invocation_options = {}) ⇒ Object Also known as: state_mv
Invokes the terraform state mv command which moves an item in the state.
This command will move an item matched by the address given to the destination address. This command can also move to a destination address in a completely different state file.
This can be used for simple resource renaming, moving items to and from a module, moving entire modules, and more. And because this command can also move data to a completely new state, it can also be used for refactoring one configuration into multiple separately managed Terraform configurations.
This command will output a backup copy of the state prior to saving any changes. The backup cannot be disabled. Due to the destructive nature of this command, backups are required.
If you're moving an item to a different state file, a backup will be created for each state file.
1053 1054 1055 1056 |
# File 'lib/ruby_terraform.rb', line 1053 def state_move(parameters = {}, = {}) exec(RubyTerraform::Commands::StateMove, parameters, ) end |
#state_pull(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state pull command which pulls the state from its location, upgrades the local copy, and outputs it to stdout.
This command “pulls” the current state and outputs it to stdout. As part of this process, Terraform will upgrade the state format of the local copy to the current version.
The primary use of this is for state stored remotely. This command will still work with local state but is less useful for this.
1080 1081 1082 1083 |
# File 'lib/ruby_terraform.rb', line 1080 def state_pull(parameters = {}, = {}) exec(RubyTerraform::Commands::StatePull, parameters, ) end |
#state_push(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state push command which updates remote state from a local state file.
This command “pushes” a local state and overwrites remote state with a local state file. The command will protect you against writing an older serial or a different state file lineage unless you pass true
for the :force
option.
This command works with local state (it will overwrite the local state), but is less useful for this use case.
If :path
is “-”, then this command will read the state to push from stdin. Data from stdin is not streamed to the backend: it is loaded completely (until pipe close), verified, and then pushed.
1125 1126 1127 1128 |
# File 'lib/ruby_terraform.rb', line 1125 def state_push(parameters = {}, = {}) exec(RubyTerraform::Commands::StatePush, parameters, ) end |
#state_remove(parameters = {}, invocation_options = {}) ⇒ Object Also known as: state_rm
Invokes the terraform state rm command which removes one or more items from the Terraform state, causing Terraform to “forget” those items without first destroying them in the remote system.
This command removes one or more resource instances from the Terraform state based on the addresses given. You can view and list the available instances with #state_list.
If you give the address of an entire module then all of the instances in that module and any of its child modules will be removed from the state.
If you give the address of a resource that has “count” or “for_each” set, all of the instances of that resource will be removed from the state.
1179 1180 1181 1182 |
# File 'lib/ruby_terraform.rb', line 1179 def state_remove(parameters = {}, = {}) exec(RubyTerraform::Commands::StateRemove, parameters, ) end |
#state_replace_provider(parameters = {}, invocation_options = {}) ⇒ Object
Invoke the terraform state replace-provider command which replaces provider for resources in the Terraform state.
Terraform will write it to the same path as the state file with a “.backup” extension.
1222 1223 1224 1225 |
# File 'lib/ruby_terraform.rb', line 1222 def state_replace_provider(parameters = {}, = {}) exec(RubyTerraform::Commands::StateReplaceProvider, parameters, ) end |
#state_show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform state show command which shows the attributes of a resource in the Terraform state.
This command shows the attributes of a single resource in the Terraform state. The :address
argument must be used to specify a single resource. You can view the list of available resources with #state_list.
1248 1249 1250 1251 |
# File 'lib/ruby_terraform.rb', line 1248 def state_show(parameters = {}, = {}) exec(RubyTerraform::Commands::StateShow, parameters, ) end |
#taint(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform taint command which marks a resource instance as not fully functional.
Terraform uses the term “tainted” to describe a resource instance which may not be fully functional, either because its creation partially failed or because you've manually marked it as such using this command.
This will not modify your infrastructure directly, but subsequent Terraform plans will include actions to destroy the remote object and create a new object to replace it.
You can remove the “taint” state from a resource instance using the #untaint command.
The address is in the usual resource address syntax, such as:
-
aws_instance.foo
-
aws_instance.bar[1]
-
module.foo.module.bar.aws_instance.baz
Use your shell's quoting or escaping syntax to ensure that the address will reach Terraform correctly, without any special interpretation.
1314 1315 1316 1317 |
# File 'lib/ruby_terraform.rb', line 1314 def taint(parameters = {}, = {}) exec(RubyTerraform::Commands::Taint, parameters, ) end |
#untaint(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform untaint command which removes the 'tainted' state from a resource instance.
Terraform uses the term “tainted” to describe a resource instance which may not be fully functional, either because its creation partially failed or because you've manually marked it as such using the #taint command.
This command removes that state from a resource instance, causing Terraform to see it as fully-functional and not in need of replacement.
This will not modify your infrastructure directly. It only avoids Terraform planning to replace a tainted instance in a future operation.
1373 1374 1375 1376 |
# File 'lib/ruby_terraform.rb', line 1373 def untaint(parameters = {}, = {}) exec(RubyTerraform::Commands::Untaint, parameters, ) end |
#validate(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform validate command which checks whether a configuration is valid.
Validates the configuration files in a directory, referring only to the configuration and not accessing any remote services such as remote state, provider APIs, etc.
Validate runs checks that verify whether a configuration is syntactically valid and internally consistent, regardless of any provided variables or existing state. It is thus primarily useful for general verification of reusable modules, including correctness of attribute names and value types.
It is safe to run this command automatically, for example as a post-save check in a text editor or as a test step for a re-usable module in a CI system.
Validation requires an initialized working directory with any referenced plugins and modules installed. To initialize a working directory for validation without accessing any configured remote backend, use the #init command passing :backend
as false
.
To verify configuration in the context of a particular run (a particular target workspace, input variable values, etc), use the #plan command instead, which includes an implied validation check.
1424 1425 1426 1427 |
# File 'lib/ruby_terraform.rb', line 1424 def validate(parameters = {}, = {}) exec(RubyTerraform::Commands::Validate, parameters, ) end |
#workspace(parameters = {}, invocation_options = {}) ⇒ Object
rubocop:disable Metrics/MethodLength
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 |
# File 'lib/ruby_terraform.rb', line 1561 def workspace(parameters = {}, = {}) case parameters[:operation] when nil, 'list' exec(RubyTerraform::Commands::WorkspaceList, parameters, ) when 'select' exec(RubyTerraform::Commands::WorkspaceSelect, parameters, ) when 'new' exec(RubyTerraform::Commands::WorkspaceNew, parameters, ) when 'delete' exec(RubyTerraform::Commands::WorkspaceDelete, parameters, ) when 'show' exec(RubyTerraform::Commands::WorkspaceShow, parameters, ) else raise( "Invalid operation '#{parameters[:operation]}' supplied to workspace" ) end end |
#workspace_delete(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace delete command which deletes a workspace.
1456 1457 1458 1459 |
# File 'lib/ruby_terraform.rb', line 1456 def workspace_delete(parameters = {}, = {}) exec(RubyTerraform::Commands::WorkspaceDelete, parameters, ) end |
#workspace_list(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace list command which lists workspaces.
1478 1479 1480 1481 |
# File 'lib/ruby_terraform.rb', line 1478 def workspace_list(parameters = {}, = {}) exec(RubyTerraform::Commands::WorkspaceList, parameters, ) end |
#workspace_new(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace new command which creates a new workspace.
1510 1511 1512 1513 |
# File 'lib/ruby_terraform.rb', line 1510 def workspace_new(parameters = {}, = {}) exec(RubyTerraform::Commands::WorkspaceNew, parameters, ) end |
#workspace_select(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace select command which selects a workspace.
1535 1536 1537 1538 |
# File 'lib/ruby_terraform.rb', line 1535 def workspace_select(parameters = {}, = {}) exec(RubyTerraform::Commands::WorkspaceSelect, parameters, ) end |
#workspace_show(parameters = {}, invocation_options = {}) ⇒ Object
Invokes the terraform workspace show command which shows the name of the current workspace.
1554 1555 1556 1557 |
# File 'lib/ruby_terraform.rb', line 1554 def workspace_show(parameters = {}, = {}) exec(RubyTerraform::Commands::WorkspaceShow, parameters, ) end |


Ecological niche models for every studied species. Geographic projections of inferred ecological niche models from the species studied for present and future RCP 2.6 and RCP 8.5 climate scenarios. (A–C) Berberis trifoliolata. (C–E) Ephedra aspera. (G–I) Leucophyllum laevigatum. (J–L) Lindleya mespiloides. (M–O) Setchellanthus caeruleus.


Module sqltable.env
Methods for the Environment object: the top level user API to SqlTable.
Functions
| _sqltable_env.connections (this) | Returns how many connections SqlTable has open to the database. |
| _sqltable_env.close (this) | Shuts down this environment. |
| _sqltable_env.reset (this) | Reset the environment: leave the environment open, but close all existing connections and open new ones for future calls. |
| _sqltable_env.setup_hook (this, fcn) | Provide a setup hook for new database connections that are opened, to configure any variables/PRAGMA options/etc that may be needed. |
| _sqltable_env.exec (this, query[, values[, callback]]) | Manually execute a database query. |
| _sqltable_env.select () | Manually perform a select statement. |
| _sqltable_env.insert () | Manually perform an insert statement. |
| _sqltable_env.update () | Manually perform an update statement. |
| _sqltable_env.delete () | Manually perform a delete statement. |
| _sqltable_env.count (tbl[, clause[, ...]]) | Execute a select that counts rows. |
| _sqltable_env.version (this) | Returns a version string identifying the version of the underlying database. |
| _sqltable_env.all_rows (tbl) | Execute a select all rows, returning an iterator. |
| _sqltable_env.where (tbl[, clause[, ...]]) | Execute a select, as limited by a where clause, returning an iterator. |
| _sqltable_env.last_insert_id (tbl) | Retrieve the primary key of the last row that was inserted. |
| _sqltable_env.placeholder (this[, nth]) | Writes a placeholder value for use in where statements. |
| _sqltable_env.debugging (this, fcn) | Apply a debugging hook to this environment. |
| _sqltable_env.clone (tbl, where, ...) | Slurps the result set of an entire query into memory so that normal pairs() can work. |
| _sqltable_env.iclone (tbl, where, ...) | Slurps the result set of an entire query into memory so that normal ipairs() can work. |
| _sqltable_env.begin_transaction (this, tbl) | Start a consistant transaction on a table. |
| _sqltable_env.commit (this, tbl) | Commit a table's transaction. |
| _sqltable_env.rollback (this, tbl) | Rollback a table's transaction
All changes will be reverted back to when begin_transaction was run. |
| _sqltable_env.open_table (this, params) | Open a proxy table to a database table. |
Tables
| TableParameters | Arguments for opening a table. |
Fields
| _sqltable_env.next | A 'magic' value: when inserting new rows with auto incrementing primary keys, we don't have a key yet. |
Functions
- _sqltable_env.connections (this)
-
Returns how many connections SqlTable has open
to the database.
Parameters:
- this Environment object
Returns:
-
Number of existant connections
- _sqltable_env.close (this)
-
Shuts down this environment.
Parameters:
- this Environment object being closed
Returns:
-
Nothing.
- _sqltable_env.reset (this)
-
Reset the environment: leave the environment open, but close
all existing connections and open new ones for future calls.
This method comes in handy should your Lua script fork into a second process.
Parameters:
- this Environment object being reset
Returns:
-
Nothing.
- _sqltable_env.setup_hook (this, fcn)
-
Provide a setup hook for new database connections that are opened,
to configure any variables/PRAGMA options/etc that may be needed.
The pool will be reset once a hook is set, thus closing all open connections and reconnecting.
Parameters:
- this Environment object being reset
- fcn Function to implement connection setup
Returns:
-
Nothing.
- _sqltable_env.exec (this, query[, values[, callback]])
-
Manually execute a database query.
The arguments returned to the callback function are raw LuaDBI Userdata. See documentation for LuaDBI at http://code.google.com/p/luadbi/w/list for API details.
Parameters:
- this Environment object
- query Text of SQL query to execute
- values Table of values to bind to the query (if needed) (optional)
- callback Function that is called to handle returned data (optional)
Usage:
t:exec( "select name from t_employees where where title = $1", { 'Programmer' }, function( connection, statement ) local row = true while row do row = statement:fetch(true) do_stuff(row) end end )
- _sqltable_env.select ()
- Manually perform a select statement.
- _sqltable_env.insert ()
- Manually perform an insert statement.
- _sqltable_env.update ()
- Manually perform an update statement.
- _sqltable_env.delete ()
- Manually perform a delete statement.
- _sqltable_env.count (tbl[, clause[, ...]])
-
Execute a select that counts rows.
Parameters:
- tbl Table being row counted
- clause Optional where clause (optional)
- ... Optional bound parameters for where clause (optional)
Returns:
-
Integer number of rows
Usage:
total_employees = env.count( t_employees ) programmers = env.count( t_employees, "where title = $1", 'Programmer' )
- _sqltable_env.version (this)
-
Returns a version string identifying the version of the
underlying database.
Please note that the exact format of the returned data may vary from database to database.
Parameters:
- this
Returns:
-
String containing version information
- _sqltable_env.all_rows (tbl)
-
Execute a select all rows, returning an iterator.
Parameters:
- tbl Table to select from
Returns:
-
Iterator function similar in usage to pairs().
Usage:
for id, employee in env.all_rows( t_employees ) do print(id, employee.name) end
- _sqltable_env.where (tbl[, clause[, ...]])
-
Execute a select, as limited by a where clause, returning an
iterator. Identical to all_rows() except permits a where clause.
Parameters:
- tbl Table to select from
- clause Optional where clause (optional)
- ... Optional bound parameters for where clause (optional)
Returns:
-
Iterator function similar in usage to pairs().
Usage:
for id, employee in env.where( t_employees, "title = $1", 'Programmer' ) do print(id, employee.name) end
- _sqltable_env.last_insert_id (tbl)
-
Retrieve the primary key of the last row that was inserted.
Parameters:
- tbl Table object that last query was performed on
Returns:
-
Primary key of last insert.
See also:
Usage:
t_employees[ sqltable.next ] = { name = 'Alice', title = 'Programmer' } alice_id = env.last_insert_id( t_employees )
- _sqltable_env.placeholder (this[, nth])
-
Writes a placeholder value for use in where statements. Helps make
manually crafted queries more portable across databases.
Parameters:
- this Environment object
- nth Specify that this is the n-th placeholder in this query (needed by some database engines) (optional)
Usage:
sql = "where column = " .. env:placeholder(1) -- "where column = $1" for PostgreSQL -- "where column = ?" for MySQL
- _sqltable_env.debugging (this, fcn)
-
Apply a debugging hook to this environment. Any SQL call made will
be passed to the function, along with a table of any bound
parameters placed as part of the call.
The hook is called before the code is compiled, so the given callback function will be called just before an error is raised.
The hook can be disabled by calling this method again with no arguments.
Parameters:
- this Environment object
- fcn Debugging function
Usage:
function sql_debug( q, args ) print(q) for k, v in pairs(args) do print(k, '"'..tostring(v)..'"') end end db.env:debugging( sql_debug )
- _sqltable_env.clone (tbl, where, ...)
-
Slurps the result set of an entire query into memory so that normal
pairs() can work. The key is chosen from the table's specified key
column.
THIS IS NOT VERY PERFORMANT WHEN USED WITH LARGE TABLES. Use caution.
Parameters:
- tbl Table object to clone
- where Optional where clause
- ... Parameters to where clause
Returns:
-
Table of data as returned by select
Usage:
programmers = env.clone( t_employees, "where title = $1", 'Programmer' ) all_employees = env.clone( t_employees ) for name, title in pairs(all_employees) do print(name, title) end
- _sqltable_env.iclone (tbl, where, ...)
-
Slurps the result set of an entire query into memory so that normal
ipairs() can work. The key starts at one and increments per row,
forming a standard Lua array.
THIS IS NOT VERY PERFORMANT WHEN USED WITH LARGE TABLES. Use caution.
Parameters:
- tbl Table object to clone
- where Optional where clause
- ... Parameters to where clause
Returns:
-
Table of data as returned by select
Usage:
programmers = env.iclone( t_employees, "where title = $1", 'Programmer' ) all_employees = env.iclone( t_employees ) for employee_id, name in ipairs(all_employees) do print(employee_id, name) end
- _sqltable_env.begin_transaction (this, tbl)
-
Start a consistant transaction on a table.
The table will be locked to a single SQL connection with autocommit mode disabled and a new transaction started. You will need to call 'commit' or 'rollback' before the table is garbage collected, or a SQL connection will be leaked.
Parameters:
- this SqlTable environment
- tbl Table transaction is starting on
- _sqltable_env.commit (this, tbl)
-
Commit a table's transaction.
All changes to the table will be saved. The SQL connection will be returned to the pool and set back to autocommit mode.
Parameters:
- this SqlTable environment
- tbl Table to commit to transaction on
- _sqltable_env.rollback (this, tbl)
-
Rollback a table's transaction
All changes will be reverted back to when begin_transaction was run. The SQL connection will be returned to the pool and set back to autocommit mode.
Parameters:
- this SqlTable environment
- tbl Table to rollback transaction on
- _sqltable_env.open_table (this, params)
-
Open a proxy table to a database table.
Parameters:
- this Environment Object
- params TableParameters
Returns:
-
Proxy table object
Usage:
t_employees = assert(env:open_table{ name = 'employees', key = 'employee_id' })
Tables
- TableParameters
-
Arguments for opening a table.
Fields:
- name Name of table, in database
- key Primary key of table
- vendor Table of database-specific parameters
- readonly If set to true, updates, inserts, and deletes will be disabled.


Select or paste an image:
Made with QR Scanner. To scan from your camera, use Instascan Demo or QR Scanner Demo.


Pakistan is centre of different civilizations, cultures: Nafees Zakaria
by https://www.facebook.com/dunyanewsLONDON (Dunya News) - Pakistan High Commission in London arranged an event on inauguration of Kartarpur Corridor and promotion of tourism in Pakistan. Governor Gilgit-Baltistan, key figures of Sikh community and other communities living in Britain were also present on the occasion.
International bloggers, who visited Pakistan recently, were also present on the occasion. They were of the view that Pakistan is a peaceful country and its people are very hospitable.
Speaking on the occasion, Pakistani High Commissioner Nafees Zakaria said that Pakistan is the centre of different civilizations and cultures. He said that Sikh community will be able to visit their religious places freely with the opening of Kartarpur Corridor. He was of the view that this will also increase the opportunities of foreign investment in Pakistan.
The Sikh community appreciated the Government of Pakistan s initiatives and commitment to the opening of Kartarpur Corridor. Sikh community in UK welcomed the decision of opening Kartarpur Corridor and also thanked the government of Pakistan.
Talking exclusively to Dunya News, Sikh leaders said that Pakistan has won the hearts of Sikhs living all over the world by giving them access to the Gurdwara Kartarpur Sahib.


Running Queries:
Refreshing in:
seconds
-- PAUSED press ESCAPE to continue --
USER
SECONDS
HOSTNAME
QUERY
Query Details:


Toggle navigation
Ledger
ata
Refiner
DASHBOARD
OVERVIEW
BLOCKS
TRANSACTIONS
HISTORY
ADVANCED QUERY
Query by Time
Query by Doc Key
Select The Creator of Tx
Select the Chaincode Name
×
Document Details
Block Height
Tx Number
Tx Hash
Chaincode Name
Tx Type
Creator MSP
Endorser MSP
Doc Key
Doc Content
Is Delete
Create Time


@import actors._ @(emailsInfo: List[EmailInfo], link: String)
Hi Knolders,
A gentle reminder to please share your feedback for the following session(s) latest by the end of the day.
The scale on which the rating will be calculated
Your feedback is valuable for the presenter, Click Here to submit your feedback.
Thanks,
Admin


E. Lawrey
Electrical and Computer Engineering
James Cook University, Douglas Campus, Townsville, Queensland, 4814,
Australia
Email<EMAIL_ADDRESS>|
Published: Fifth International Symposium on Signal Processing
and its Applications,
ISSPA 99, Brisbane, Australia, 22-25 August, 1999
Organised by the Signal Processing Research Centre, QUT, Brisbane,
Australia
|
Click on each of the pages of the poster to get a larger (readable)
version.
(209kB) Describes what multiuser OFDM is, and how it is generated
(237kB) Describes the use of Access Point Repeaters, and Adaptive Frequency Hopping
(194kB) Describes Adaptive Modulation and a low bandwidth OFDM test system
| Copyright 1997-2001 Eric Lawrey,
Last Updated: 2nd December 2001 |
|


ECL standard library style guide
The ECL code in the standard library should follow the following style guidelines:
- All ECL keywords in upper case
- ECL reserved types in upper case
- Public attributes in camel case with leading upper case
- Private attributes in lower case with underscore as a separator
- Field names in lower case with underscore as a separator
- Standard indent is 2 spaces (no tabs)
- Maximum line length of 120 characters
- Compound statements have contents indented, and END is aligned with the opening statement
- Field names are not indented to make them line up within a record structure
- Parameters are indented as necessary
For example:
my_record := RECORD
INTEGER4 id;
STRING firstname{MAXLENGTH(40)};
STRING lastname{MAXLENGTH(50)};
END;
/**
* Returns a dataset of people to treat with caution matching a particular lastname. The
* names are maintained in a global database of undesirables.
*
* @param search_lastname A lastname used as a filter
* @return The list of people
* @see NoFlyList
* @see MorePeopleToAvoid
*/
EXPORT DodgyCharacters(STRING search_lastname) := FUNCTION
raw_ds := DATASET(my_record, 'undesirables', THOR);
RETURN raw_ds(last_name = search_lastname);
END;
Some additional rules for attributes in the library:
- Services should be SHARED and EXPORTed via intermediate attributes
- All attributes must have at least one matching test. If you're not on the test list you're not coming in.


Web Developer Checklist
Get the extension
Chrome
|
Firefox
|
Edge
Menu
Home
Demo mode
Source on GitHub
Best practices
Fix broken links
◄
W3C link checker
Spelling and grammar
◄
Capitalization
Writing Style
Word Variations e.g. UK vs US
Check website in all browsers
◄
BrowserShots.org
Browserling.com
Spoon.net
Decide on www-subdomain
◄
no-www.org score of 'B'
...or www.yes-www.org
Handle 'www' in web.config
Mobile
Mobile-Friendly Test
◄
Mobile Friendly checker
Use 'viewport' meta-tag
◄
Don’t Forget the Viewport Meta Tag
Make your website mobile friendly
Use correct input types
◄
Input type: Email, Url, Phone
Diving in to HTML5 forms
Manual check using emulators
◄
Online media query tester
6 free mobile emulators
Opera Mobile Emulator
Test using real devices
◄
Use Open Device Labs to test multiple devices
Analytics
Uptime monitoring
◄
Uptime robot
GotSiteMonitor.com
Traffic analysis
◄
Google Analytics
StatCounter
Clicky
Piwik
Performance
Google Page Speed score of 90+
◄
Google Page Speed
Optimize HTTP headers
◄
redbot.org
Optimize images
◄
kraken.io
PunyPNG.com
PNGGauntlet for Windows
Image Optim for Mac
Usability
mod
HTML5 compatibility check
◄
Compat Inspector
modern.IE
Modernizr JS library
Custom 404 page
◄
A more useful 404
Favicon
◄
Real Favicon Generator
Favicon Cheat Sheet
Use friendly URLs
◄
11 best practices for URLs
URL rewriting in IIS
URL rewrite in Apache
Print-friendly CSS
◄
Set up a print stylesheet
Add search feature
◄
Google Custom Search
Consider 'Open Search'
Environment Integration
◄
Safari on iOS
Internet Explorer on Windows
Windows 8 Tiles
Semantics
Add meaning with structured data
◄
Schema.org reference
Schema-Creator.org
Check the semantics
◄
W3C semantic extractor
Google Structured Data Testing Tool
Facebook OpenGraph Debugger
Twitter Card Validator
SEO
SenSEO score of 85+
◄
SenSEO for Firefox
Google Rich Snippets
◄
Online tester
Getting started
robots.txt
◄
robots.txt tutorial
Create robots.txt online
XML sitemap
◄
Create sitemap online
Code quality
HTML validation
◄
W3C HTML validator
Dr. Watson
CSS validation
◄
W3C CSS validator
Run CSS Lint
◄
Run CSS Lint online
Run JSLint/JSHint
◄
Run JSLint online
Run JSHint online
World ready
◄
W3C i18n checker
Automated testing
◄
Testomato
Accessibility
Accessibility validation
◄
Common problems and solutions
IDI Web Accessibility Checker
Test using a screen reader
Color contrast
◄
Check color contrast online
WAI-ARIA Landmarks
◄
Using WAI-ARIA Landmarks
Guide to WAI-ARIA
Practical examples
Security
Follow best practices
◄
ASafaaWeb security analyzer
Observatory by Mozilla
Cross-site scripting
◄
XSS cheat sheet
DOM based XSS cheat sheet
Free XSS scanner
Cross-site request forgery
◄
Explanation and walkthrough
CSRF cheat sheet
Secure connection (SSL)
◄
Setup SSL on IIS 7
Setup SSL on Apache
SSL Server Test
HTTP Strict Transport Security
◄
MDN Overview
OWASP Overview
Enable Content Security Policy
◄
Content Security Policy
MDN Guide
OWASP Overview
CSP Tester
Social Media
Open Graph protocol
◄
Open Graph protocol reference
Twitter Cards
◄
Documentation
Facebook Insights
◄
Facebook Insights
Google+
◄
Google+ Publisher
...and finally
Add humans.txt
◄
Humans.txt generator
Optional:
0
/8


1.What was the problem?
I got heaps of problems while developing javascript racer game. I was not a javascript smart coder, but i believe that the logics of every language is same.I was stuck with table coloumn incrementing process through looping, but finally it resolved.
2.What problem solving technique did you use?
I always use the technique console.log in which helps me to get the value of variable after each page load. Also, I see the error log and find what has went wrong. Apart from the that if I am totally stuck, I search google to find the reason of error.
3.What did you learn?
I learnt lot of javascript concepts like DOM, BOM etc. I am eager to learn more new concepts in javascript.
What is .map function in javascript?
The map function method creates a new array with the results of calling provided function on every element in the array. Callback is invoked only for indexes of the array which have assigned values includes undefined.
What is .filter function in javascript?
The .filter function method creates a new array with all elements that pass the test implemented by the provided function. Filter function calls a provided callback function once for each element in an array and construct a new array of all the values for which call back returns a true value or a value coerces to true.
What is .reduce function in javascript?
The .reduce method applies a function against an accumulator and each value of the array to reduce it to a single value. reduce executes the callback function once for each element present in the array.


Information about HTML HTML JavaScript Home
*HTML is the standard markup language for creating Web pages.
*HTML stands for Hyper Text Markup Language.
*HTML describes the structure of Web pages using markup.
*HTML elements are the building blocks of HTML pages.
*HTML elements are represented by tags.


We provide nutritional food at your doorstep by creating a healthy personal routine for you
We provide you with food full of Vitamins, Proteins, Fats, Carbohydrates & Minerals to keep you healthy & help you feel fresh.
We Consult our dietitians to make a balanced diet for you with right amount of calories in your diet & our trainers are also there to help you to get results you want to achieve.
We have provided detailed documentation as well as specific code examples to help new users get started. We are also always open to feedback and can answer any questions a user may have about Materialize.


ENTER
Turn on the laser
What is this?!
Make the sample blink
Super-resolution imaging gallery
SUPER-RESOLUTION SCORE:
CHECK OUT OUR SUPER-RESOLUTION gallery!
START OVER


We aggregate content!
- facilitate leading-edge initiatives
- enhance cross-platform schemas
- synergize user-centric networks
- transition value-added e-tailers
- enhance vertical communities
- drive scalable initiatives
- incentivize cross-media relationships
- deliver value-added content


Safety measures for delivered food
Leading experts at the FDA say there are no known risks or evidence that suggests that COVID-19 can be transmitted by food or food packaging. The more apparent risk with food delivery and takeout is face to face contact with couriers or restaurant staff. There are a few ways you can reduce this risk and still safely enjoy your favorite meals
With many non-essential businesses closed for the indefinite future, many restaurants have transitioned to delivery only. You can rest easy knowing that eating your favorite meals in the comfort of your own home shouldn't put you at an elevated risk
Foodborne exposure to this virus is not known to be a route of transmission. The overwhelming risk comes from being in close proximity to an infected person, especially if they sneeze or cough," he explains.
“Contactless” delivery
If you're calling a local restaurant to arrange delivery, ask them up front to keep your delivery contactless if possible, simply allowing the courier to leave your meal on your doorstep, front porch, or within your building's lobby.
The bag the food is delivered in should be your concern, since the virus that causes COVID-19 can reportedly survive for 24 hours on paper or cardboard, as well as 72 hours on plastic.
- Place the delivery bag in your sink. Don't let it sit directly on other counter spaces in your kitchen or in the home. You can sanitize or disinfect your sink after the meal is over, and after you've thrown the delivery bag into the trash or recycling, along with any containers
- Plate your food, or transfer it to another clean container in your kitchen. Be sure to avoid touching the food directly; use a clean utensil instead. Don't put any plastic, paper, or cardboard containers in your cupboard or your fridge, as it's unclear if cold temperatures can neutralize the virus currently.
- Wash your hands!  At some point, you should also wipe down your sink with a disinfecting wipe


Iurie Gaitur
Software engineer
Iurie Gaitur is an enthusiast in software engineering and doing it for more than 4 years.
Iurie has a strong technical background in Android development and interested in mobile technologies especially iOS and React Native.
Though Iurie is also interesting in Javascript, especially in NodeJS and AureliaJS.


angular-scroll module provides scroll service and combination of scroll-root and scroll-item directives.
Example of scroll-root and scroll-item directives usage:
Example of scroll service usage:
Also angular-scroll works good with nested scrollable elements.


Welcome!
You appear to have revoked permission for {{org_name}} to write to your ORCID record,
If you want this to happen you'll need to give them permission again...
Please click on the link below to login on ORCIDHUB via ORCID
{{ invitation_url }}
Once you click this link, you'll be taken to ORCID to sign in to, or create, your ORCID record. Once you've granted permission, you'll be automatically taken to the Hub. Note no further action from you is needed. In the next minute or so, the affiliation will be shown in your ORCID record.


Favorite Things
Input some of your favorite things, and then see the list displayed
First thing:
Second thing:
Third thing:
Submit
Your favorite things:


In order to build the library, you need a 'C' compiler (obvious, isn't it?) and a set of header files for the networking API definitions. The networking header files go into a directory netinclude which has to sit in the same directory as the source code and the include directory you find in there. I'm not currently supplying these header files here. Drop me a line, and I'll take care of that.
The SAS/C flavour (smakefile) should get the library built using the "large data" model. This rules out the use of residentable programs as the startup code I'm using is very primitive (startup.o) and doesn't tinker with A4 relative data addressing (and how this may be set up).
There are two makefiles for GCC, each a different flavour. There is GNUmakefile.68k, which will build the library for GCC on the 68k platform ("classic" Amiga). This builds all variants of the library, for large data, small data, resident, whatever model. It's a lot of work and I don't recommend you do this on a plain 68k machine. It will literally (!) take hours. The other makefile flavour is for AmigaOS4 using the PowerPC hosted GCC system (GNUmakefile.os4). This builds only the large data version of the library, but this is usually all you need. Small data support is currently not implemented but might follow in the future.


Implementing a Module¶
This chapter details how to implement a core module in MicroPython. MicroPython modules can be one of the following:
Built-in module: A general module that is be part of the MicroPython repository.
User module: A module that is useful for your specific project that you maintain in your own repository or private codebase.
Dynamic module: A module that can be deployed and imported at runtime to your device.
A module in MicroPython can be implemented in one of the following locations:
py/: A core library that mirrors core CPython functionality.
extmod/: A CPython or MicroPython-specific module that is shared across multiple ports.
ports/<port>/: A port-specific module.
Note
This chapter describes modules implemented in py/
or core modules.
See Extending MicroPython in C for details on implementing an external module.
For details on port-specific modules, see Porting MicroPython.
Implementing a core module¶
Like CPython, MicroPython has core builtin modules that can be accessed through import statements.
An example is the gc
module discussed in Memory Management.
>>> import gc
>>> gc.enable()
>>>
MicroPython has several other builtin standard/core modules like io
, array
etc.
Adding a new core module involves several modifications.
First, create the C
file in the py/
directory. In this example we are adding a
hypothetical new module subsystem
in the file modsubsystem.c
:
#include "py/builtin.h"
#include "py/runtime.h"
#if MICROPY_PY_SUBSYSTEM
// info()
STATIC mp_obj_t py_subsystem_info(void) {
return MP_OBJ_NEW_SMALL_INT(42);
}
MP_DEFINE_CONST_FUN_OBJ_0(subsystem_info_obj, py_subsystem_info);
STATIC const mp_rom_map_elem_t mp_module_subsystem_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_subsystem) },
{ MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&subsystem_info_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_subsystem_globals, mp_module_subsystem_globals_table);
const mp_obj_module_t mp_module_subsystem = {
.base = { &mp_type_module },
.globals = (mp_obj_dict_t *)&mp_module_subsystem_globals,
};
MP_REGISTER_MODULE(MP_QSTR_subsystem, mp_module_subsystem, MICROPY_PY_SUBSYSTEM);
#endif
The implementation includes a definition of all functions related to the module and adds the
functions to the module’s global table in mp_module_subsystem_globals_table
. It also
creates the module object with mp_module_subsystem
. The module is then registered with
the wider system via the MP_REGISTER_MODULE
macro.
After building and running the modified MicroPython, the module should now be importable:
>>> import subsystem
>>> subsystem.info()
42
>>>
Our info()
function currently returns just a single number but can be extended
to do anything. Similarly, more functions can be added to this new module.


| Posted 1/28/2019 | Click here to verify Key Dates | Download page to print | ||||
| January 22 | Spring semester begins | |||||
| April 1 - April 7 | Spring Break | |||||
| ELECTRICAL AND COMPUTER ENGINEERING | April 1 | Cesar Chavez Day, University closed | ||||
| May 11 | Spring classes end | |||||
| May 13 | Finals Study Day, no classes | |||||
| SPRING SEMESTER 2019 COURSE LIST | May 14-18 | Final exams | ||||
| May 20, 21, 22 | University Commencements | |||||
| May 24 | Spring semester ends | |||||
| COURSE | TITLE | CR | FACULTY | DAYS/TIMES | ROOM | |
| EE2040 | Circuit Analysis I | 3 | Rad | TR 1215-130PM | FA347 | |
| EE2049-01 | Electrical Measurements and Circuits Laboratory | 1 | Shahverdi | F 100-330PM | ETC249 | |
| EE2049-02 | Electrical Measurements and Circuits Laboratory | 1 | Linker | M 600-830PM | ETC249 | |
| EE2049-03 | Electrical Measurements and Circuits Laboratory | 1 | Lin | W 600-830PM | ETC249 | |
| EE2049-04 | Electrical Measurements and Circuits Laboratory | 1 | Lin | T 800-1030AM | ETC249 | |
| EE2440-03 | Digital Engineering | 2 | Ghaforyfard | F 800-950AM | ETC256 | |
| EE2440-04 | Digital Engineering | 1 | Ghaforyfard | W 200-430PM | ETC256 | |
| EE2440-05 | Digital Engineering | 2 | Liu | T 1000-1150AM | ETC256 | |
| EE2440-06 | Digital Engineering | 1 | Liu | R 1100AM-130PM | ETC256 | |
| EE2449-01 | Digital Logic Laboratory | 1 | Lin | F 800-1030AM | ETC248 | |
| EE2449-02 | Digital Logic Laboratory | 1 | Kim | T 600-830PM | ETC248 | |
| EE2449-04 | Digital Logic Laboratory | 1 | Zhao | M 1100AM-130PM | ETC248 | |
| EE2449-05 | Digital Logic Laboratory | 1 | Zhao | W 1100AM-130PM | ETC248 | |
| EE2450-01 | Embedded System Programming I | 2 | Warter-Perez | T 800-950AM | ETC256 | |
| EE2450-02 | Embedded System Programming I | 1 | Warter-Perez | R 800-1030AM | ETC256 | |
| EE2450-05 | Embedded System Programming I | 2 | Ghaforyfard | W 1000-1150AM | ETC256 | |
| EE2450-06 | Embedded System Programming I | 1 | Ghaforyfard | F 1100AM-130PM | ETC256 | |
| EE3000 | Economics for Engineers | 3 | Gharibian | F 400-645PM | ETA126 | |
| EE3001 | Numerical Analysis and Modeling Using MATLAB | 1 | Zhao | T 200-430PM | ETC255G | |
| EE3010 | Ethics and Professionalism in Engineering | 3 | Schaff/Mmeje | MW 600-715PM | FA218 | |
| EE3020 | Signals and Systems | 3 | Rad | TR 1050AM-1205PM | FA218 | |
| EE3030 | Circuit Analysis II | 3 | Tabrizi | TR 1215-130PM | SH260 | |
| EE3200 | Analog Communication Systems | 3 | Tabrizi | TR 925-1040AM | SH260 | |
| EE3300-01 | Electric Machines | 3 | Rad | TR 925-1040AM | FA347 | |
| EE3300-02 | Electric Machines | 3 | Abed | R 600-845PM | ETA209 | |
| EE3309-01 | Electromagnetic Energy Conversion Laboratory | 1 | Fragoso | T 600-830PM | ETA209 | |
| EE3309-02 | Electromagnetic Energy Conversion Laboratory | 1 | Abbasi | M 600-830PM | ETA209 | |
| EE3445-01 | Computer Organization for CS students | 3 | Lim | MW 140-255PM | BIOS352 | |
| EE3445-02 | Computer Organization for CS students | 3 | Lim | MW 1215-130PM | BIOS352 | |
| EE3445-03 | Computer Organization for CS students | 3 | Lim | MW 305-420PM | BIOS352 | |
| EE3450-01 | Embedded Systems Programming II | 2 | Zhang | T 200-350PM | ETC256 | |
| EE3450-02 | Embedded Systems Programming II | 1 | Zhang | F 200 - 430PM | ETC256 | |
| EE3450-03 | Embedded Systems Programming II | 2 | Zhang | M 600-740PM | ETC256 | |
| EE3450-04 | Embedded Systems Programming II | 1 | Zhang | F 600-830PM | ETC256 | |
| EE3450-05 | Embedded Systems Programming II | 2 | Zhang | M 750-930PM | ETC256 | |
| EE3450-06 | Embedded Systems Programming II | 1 | Zhang | W 600-830PM | ETC256 | |
| EE3600 | Control Systems I | 3 | Tabrizi | TR 1050AM-1205PM | SH260 | |
| EE3700 | Electronics I | 3 | Tabrizi | MW 1215-130PM | SH260 | |
| EE3720 | Digital Electronics | 3 | Rad | MW 140-255PM | FA347 | |
| EE3810-01 | Sensors, Data Acquisition, and Instrumentation with application to Biomedical Engineering | 2 | Won/Karuhaka | TR 200-250PM | KHC4075 | |
| EE3810-03 | Sensors, Data Acquisition, and Instrumentation with application to Biomedical Engineering | 1 | Lee | F 200-430PM | ETC251 and ETC252 | |
| EE3810-04 | Sensors, Data Acquisition, and Instrumentation with application to Biomedical Engineering | 2 | Won/Karuhaka | TR 200-250PM | KHC4075 | |
| EE3810-05 | Sensors, Data Acquisition, and Instrumentation with application to Biomedical Engineering | 1 | Lee | F 1100AM-130PM | ETC252 and ETC251 | |
| EE4130 | Systems Engineering | 3 | Harris | MW 430-545PM | ETA331 | |
| EE4220 | Digital Signal Processing | 3 | Mondin | TR 430-545PM | ETC255D | |
| EE4229 | Digital Signal Processing Lab | 1 | Emrani | W 600-830PM | ETC252 | |
| EE4300 | Introduction to Power Systems Engineering | 3 | Habibi-Ashrafi | TR 140-255PM | KHB4015 | |
| EE4310 | Power Systems Analysis | 3 | Shahverdi | TR 430-545PM | ETA209 | |
| EE4320 | Electric Power Distribution | 3 | Jamehbozorg | TR 1215-130PM | ETA209 | |
| EE4340 | Electromagnetic Energy Conversion | 3 | Samaan | MW 850-1005PM | ETA209 | |
| EE4440 | Computer Organization | 3 | Ghaforyfard | F 650-935PM | ETA332 | |
| EE4480-01 | Advanced Digital Design | 2 | Lin | T 600-740PM | ETC256 | |
| EE4480-02 | Advanced Digital Design | 1 | Lin | R 600-830PM | ETC256 | |
| EE4540 | ST:Machine Learning Principles and Applications | 3 | Mondin | MW 430-545PM | ETC255D | |
| EE4610 | Digital Control System | 3 | Rad | TR 850-1005PM | ETA126 | |
| EE4689 | Control Systems Laboratory | 1 | Fragoso | F 600-830PM | ETC156 | |
| EE4730 | Optoelectronics | 3 | Mansour | TR 725-840PM | ETA226 | |
| EE4820 | Biomed Signal Processing | 3 | Won | MW 140-255PM | ETC255E | |
| EE4962 | Senior Design II | 3 | Nye | F 1200-230PM | KHLH1 | |
| EE5150 | Systems Performance Analysis | 3 | Karimlou | MW 725-840PM | ETA332 | |
| EE5160 | Systems Architecture | 3 | Karimlou | MW 850-1005PM | ETB12 | |
| EE5210 | Advanced Digital Communication II | 3 | Mondin | TR 600-715PM | ETC255E | |
| EE5320 | Vehicle Electrification | 3 | Shahverdi | F 400-645PM | ETC255G | |
| EE5360 | Renwable Energy Sources in Power | 3 | Jamehbozorg | MW 430-545PM | ETA209 | |
| EE5440 | Computer System Architecture | 3 | Liu | MW 600-715PM | ETA332 | |
| EE5820 | Neural Computation | 3 | Won | TR 1215-130PM | ETA332 |


NVL2 Expression
Returns one of two values based on whether a specified expression evaluates to NULL or NOT NULL.
Syntax
NVL2 ( expression, not_null_return_value, null_return_value )
Arguments
- expression
-
An expression, such as a column name, to be evaluated for null status.
- not_null_return_value
-
The value returned if expression evaluates to NOT NULL. The not_null_return_value value must either have the same data type as expression or be implicitly convertible to that data type.
- null_return_value
-
The value returned if expression evaluates to NULL. The null_return_value value must either have the same data type as expression or be implicitly convertible to that data type.
Return Type
The NVL2 return type is determined as follows:
-
If either not_null_return_value or null_return_value is null, the data type of the not-null expression is returned.
If both not_null_return_value and null_return_value are not null:
-
If not_null_return_value and null_return_value have the same data type, that data type is returned.
-
If not_null_return_value and null_return_value have different numeric data types, the smallest compatible numeric data type is returned.
-
If not_null_return_value and null_return_value have different datetime data types, a timestamp data type is returned.
-
If not_null_return_value and null_return_value have different character data types, the data type of not_null_return_value is returned.
-
If not_null_return_value and null_return_value have mixed numeric and non-numeric data types, the data type of not_null_return_value is returned.
Important
In the last two cases where the data type of not_null_return_value is returned, null_return_value is implicitly cast to that data type. If the data types are incompatible, the function fails.
Usage Notes
DECODE Expression can be used in a similar way to NVL2 when the expression and search parameters are both null. The difference is that for DECODE, the return will have both the value and the data type of the result parameter. In contrast, for NVL2, the return will have the value of either the not_null_return_value or null_return_value parameter, whichever is selected by the function, but will have the data type of not_null_return_value.
For example, assuming column1 is NULL, the following queries will return the same value. However, the DECODE return value data type will be INTEGER and the NVL2 return value data type will be VARCHAR.
select decode(column1, null, 1234, '2345'); select nvl2(column1, '2345', 1234);
Example
The following example modifies some sample data, then evaluates two fields to provide appropriate contact information for users:
update users set email = null where firstname = 'Aphrodite' and lastname = 'Acevedo'; select (firstname + ' ' + lastname) as name, nvl2(email, email, phone) AS contact_info from users where state = 'WA' and lastname like 'A%' order by lastname, firstname; name contact_info --------------------+------------------------------------------- Aphrodite Acevedo<PHONE_NUMBER> Caldwell Acevedo<EMAIL_ADDRESS>Quinn Adams<EMAIL_ADDRESS>Kamal Aguilar<EMAIL_ADDRESS>Samson Alexander<EMAIL_ADDRESS>Hall Alford<EMAIL_ADDRESS>Lane Allen<EMAIL_ADDRESS>Xander Allison<EMAIL_ADDRESS>Amaya Alvarado<EMAIL_ADDRESS>Vera Alvarez<EMAIL_ADDRESS>Yetta Anthony<EMAIL_ADDRESS>Violet Arnold<EMAIL_ADDRESS>August Ashley<EMAIL_ADDRESS>Karyn Austin<EMAIL_ADDRESS>Lucas Ayers at@elitpretiumet.com


sweetpea.blocks module
This module provides the various kinds of blocks that can be used to create a factorial experimental design.
- class sweetpea.blocks.Block(design, crossing, constraints, require_complete_crossing, cnf_fn)
Bases:
object
Abstract class for Blocks. Contains the required data, and defines abstract methods that other blocks _must_ implement in order to work correctly.
- extract_basic_factor_names(level)
- Parameters
level (DerivedLevel) –
- Return type
- abstract trials_per_sample()
Indicates the number of trials that are generated per sample for this block configuration.
Analogous to the old
__fully_cross_size
function.
- abstract variables_per_trial()
Indicates the number of variables that are present in each trial.
Analogous to the old
__design_size
function.
- abstract grid_variables()
Indicates the number of variables that are present in the core variable grid. this does not include variables used to encode complex windows.
In a design without complex windows, this is equivalent to
Block.variables_per_sample()
.
- variables_per_sample()
Indicates the total number of variables needed to encode the core experiment description.
Alternatively stated, this returns the number of variables in the formula that constitute the independent support.
- variables_for_factor(f)
Indicates the number of variables needed to encode this factor.
- has_factor(factor)
Determines whether a given factor is in this block.
- first_variable_for_level(factor, level)
Returns the first index for this variable in a trial sequence representing the given factor and level. (0-based.)
- factor_variables_for_trial(f, t)
Given a factor and a trial number (1-based) this function will return a list of the variables representing the levels of the given factor for that trial. The variable list is also 1-based.
- variable_list_for_trial(t)
Given a trial number (1-based) this function will return a list of lists of the variables that pertain to that trial.
For example, for stroop-2 with a congruency level, this method would return the following for trial
1
:[[1, 2], [3, 4], [5, 6]]
If a transition were involved, and it didn’t apply to level one, then the factor would have an empty list:
[[1, 2], [3, 4], []]
- decode_variable(variable)
Given a variable number from the SAT formula, this method will return the associated factor and level name.
- Parameters
variable (int) –
- Return type
- is_excluded(c, d)
Given crossing and design-only variables and returns true if the combination meets any of the exclude contraints.
- filter_excluded_derived_levels(l)
Given a list of trials, the function filters the trials invalid as per the exclude contraints.
- build_backend_request()
Apply all constraints to build a
BackendRequest
. Formerly known as__desugar
.- Return type
- get_variable(trial_number, level)
Given a trial number (1-based), factor, and level, this method will return the SAT variable that represents that selection. Only works for factors without complex windows at the moment.
- build_variable_list(level_pair)
Given a specific level (factor + level pair), this method will return the list of variables that correspond to that level in each trial in the encoding.
- Parameters
level_pair (Tuple[Factor, Union[SimpleLevel, DerivedLevel]]) –
- Return type
- factor_in_crossing(factor)
- rearrage_samples(samples, results)
- calculate_samples_required(samples)
- class sweetpea.blocks.FullyCrossBlock(design, crossing, constraints, require_complete_crossing=True, cnf_fn=<function to_cnf_tseitin>)
Bases:
Block
A fully-crossed block. This block generates as many trials as needed to fully cross all levels across all factors in the block’s crossing.
- trials_per_sample()
Indicates the number of trials that are generated per sample for this block configuration.
Analogous to the old
__fully_cross_size
function.
- variables_per_trial()
Indicates the number of variables that are present in each trial.
Analogous to the old
__design_size
function.
- grid_variables()
Indicates the number of variables that are present in the core variable grid. this does not include variables used to encode complex windows.
In a design without complex windows, this is equivalent to
Block.variables_per_sample()
.
- crossing_size()
- crossing_size_without_exclusions()
- draw_design_graph()
- factor_in_crossing(factor)
- class sweetpea.blocks.MultipleCrossBlock(design, crossing, constraints, require_complete_crossing=True, cnf_fn=<function to_cnf_tseitin>)
Bases:
Block
A multiple-crossed block. This block generates as many trials as needed tocross the levels across factors mentioned as lists in the block’s crossing.
- trials_per_sample()
Indicates the number of trials that are generated per sample for this block configuration.
Analogous to the old
__fully_cross_size
function.
- variables_per_trial()
Indicates the number of variables that are present in each trial.
Analogous to the old
__design_size
function.
- grid_variables()
Indicates the number of variables that are present in the core variable grid. this does not include variables used to encode complex windows.
In a design without complex windows, this is equivalent to
Block.variables_per_sample()
.
- crossing_size()
- crossing_size_without_exclusions()
- draw_design_graph()
- factor_in_crossing(factor)


I constantly find myself in a situation where I need to have the user enter a string and find the best match for that string from a list of strings. To solve this I made a hash table of string doublets.
Skeleton program for a simple Beowulf cluster that uses ssh to communicate. Simple to use and simple to code.
Simplifies the extraction of recipes and ingredients from websites and can automatically cross-reference the nutrition against the USDA database.
Python-based Poetry generator that can generate poetry that is suitable to pass the Turing test.
The motion sensor is simply a PIR sensor connected to a 434MHz RF transmitter via an encoder. The encoder uses four bits, in the form of resistors tied to HIGH (+VCC) or LOW (GND). That's enough for 12 sensors. The ATtiny85 is programmed via an Arduino which allows for devising a smart way of sending the RF data. It can be programmed to send the output as randomized timed sequences in order to reduce the conflicts of having other motion sensors on the same band.
Artificial intelligence fully capable of STT, TTS, facial recognition and and rudimentary facial features.


val payloads: List<IngestionPayload>
: ListMapString,Any - list of map that contains details of event
payloads - : ListMapString,Any - list of map that contains details of event
payloads


jest-docblock
is a package that can extract and parse a
specially-formatted comment called a “docblock” at the top of a file.
A docblock looks like this:
Docblocks can contain pragmas, which are words prefixed by @
:
Pragmas can also take arguments:
jest-docblock
can:
const code = `
/**
* Everything is awesome!
*
* @everything is:awesome
* @flow
*/
export const everything = Object.create(null);
export default function isAwesome(something) {
return something === everything;
}
`;
const {
extract,
strip,
parse,
parseWithComments,
print,
} = require('jest-docblock');
const docblock = extract(code);
console.log(docblock); // "/**\n * Everything is awesome!\n * \n * @everything is:awesome\n * @flow\n */"
const stripped = strip(code);
console.log(stripped); // "export const everything = Object.create(null);\n export default function isAwesome(something) {\n return something === everything;\n }"
const pragmas = parse(docblock);
console.log(pragmas); // { everything: "is:awesome", flow: "" }
const parsed = parseWithComments(docblock);
console.log(parsed); // { comments: "Everything is awesome!", pragmas: { everything: "is:awesome", flow: "" } }
console.log(print({pragmas, comments: 'hi!'})); // /**\n * hi!\n *\n * @everything is:awesome\n * @flow\n */;
extract(contents: string): string
Extracts a docblock from some file contents. Returns the docblock
contained in contents
. If contents
did not
contain a docblock, it will return the empty string (""
).
strip(contents: string): string
Strips the top docblock from a file and return the result. If a file does not have a docblock at the top, then return the file unchanged.
parse(docblock: string): {[key: string]: string | string[] }
Parses the pragmas in a docblock string into an object whose keys are the pragma tags and whose values are the arguments to those pragmas.
parseWithComments(docblock: string): { comments: string, pragmas:
{[key: string]: string | string[]} }
Similar to parse
except this method also returns the comments
from the docblock. Useful when used with print()
.
print({ comments?: string, pragmas?: {[key: string]: string | string[]}
}): string
Prints an object of key-value pairs back into a docblock. If
comments
are provided, they will be positioned on the top of
the docblock.


How-to: Add a customized post-processor
We provide the ability to process output files by adding a customized post-processor.
In DocFX, the index file for full-text-search is generated by one post-processor named ExtractSearchIndex
.
In this topic, we will show how to add a customized post-processor.
Step0: Preparation
- Create a new C# class library project in
Visual Studio
. - Add nuget packages:
System.Collections.Immutable
with version 1.3.1Microsoft.Composition
with version 1.0.31
- Add
Microsoft.DocAsCode.Plugins
If you are building DocFX from source code, add this reference to the project, otherwise add the nuget packageMicrosoft.DocAsCode.Plugins
with the same version as DocFX.
Step1: Create a new class (MyProcessor.cs) with the following code:
[Export(nameof(MyProcessor), typeof(IPostProcessor))]
public class MyProcessor : IPostProcessor
{
// TODO: implements IPostProcessor
}
Step2: Update global metadata
public ImmutableDictionary<string, object> PrepareMetadata(ImmutableDictionary<string, object> metadata)
{
// TODO: add/remove/update property from global metadata
return metadata;
}
In this method, we can update the global metadata before building all the files declared in docfx.json
. Otherwise, you can just return the metadata from parameters if you don't need to change global metadata.
Using ExtractSearchIndex
for example, we add "_enableSearch": true
in global metadata. The default template would then know it should load a search box in the navbar.
Step3: Process all the files generated by DocFX
public Manifest Process(Manifest manifest, string outputFolder)
{
// TODO: add/remove/update all the files included in manifest
return manifest;
}
Input for the method manifest
contains a list of all files to process, and outputFolder
specifies the output folder where our static website will be placed. We can implement customized operations here to process all files generated by DocFX.
Note
Post-processor aims to process the output files, so the FileModel
can't be accessed in this phase. If some metadata is needed here, an option is to save it in FileModel.ManifestProperties
in build phase, then access it through ManifestItem.Metadata
. Another option is to save it somewhere in output files, like HTML's <meta>
Tag.
Using ExtractSearchIndex
for example again, we traverse all HTML files, extract key words from these HTML files and save a file named index.json
under the outputFolder
. Finally we return the manifest which is not modified.
Step4: Build your project and copy the output dll files to:
Global: the folder with name
Plugins
under DocFX.exeNon-global: the folder with name
Plugins
under a template folder, then runDocFX build
command with parameter-t {template}
.Hint: DocFX can merge templates, so we can specify multiple template folders as
DocFX build -t {templateForRender},{templateForPlugins}
. Each of the template folders should have a subfolder namedPlugins
with exported assemblies.
Step5: Add your post processor in docfx.json
In this step, we need to enable the processor by adding its name in docfx.json
. Here is an example:
{
"build": {
...
"postProcessors": ["OutputPDF", "BeautifyHTML", "OutputPDF"]
}
}
As you can see, the postProcessors
is an array, which means it could have multiple processors.
It needs to be pointed out that the order of postProcessors
written in docfx.json
is also the order to process output files.
In the above example, DocFX will run OutputPDF
first, then BeautifyHTML
, and then OutputPDF
again.
If you want to enable the post processors without changing docfx.json
, you can use the build command option like docfx build --postProcessors=OutputPDF,BeautifyHTML,OutputPDF
.
One more thing need to be noted: the build command option postProcessors
would override the corresponding configuration in docfx.json
.


This screen allows a new team to be added. It contains the 'team level' information -
not the members of the team which are added (or removed) after the team has been created.
This screen allows the description of the team to be changed. Members are added or removed from the
main management screen.


Contact Us!
Our beautiful resort is located in the Indian Ocean. Please inquire about packages and other accommodations.
Our beautiful resort is located in the Indian Ocean. Please inquire about packages and other accommodations.


arrow_back
Checkbox
Checkbox
Toggle indeterminate
Toggle RTL
Toggle End Aligned
Toggle Disabled
Light Theme
Checkbox
Custom colored checkbox (stroke, fill, ripple, and focus)
Custom colored checkbox (stroke and fill only)


Passenger JS is a UI/UX password helper tool that allows users to create passwords that meet the minimum requirements of a website or web application with greater ease. Instead of multiple page refreshes to indicate to the user what is still missing from the set of password requirements, multiple direct indicators provide instantaneous feedback as users type, to help them come up with passwords that meet the requirements of a website or application. Alongside the password requirement fulfillment feature, there is also a password show toggle ability to allow users to see what they've already typed in the password field. When users are able to create passwords faster, you have lower bounce rates, higher conversions, and you know the rest...
UX research has shown that there is a notable user frustration with user password creation across a wide range of online applications. This tool helps to alleviate that frustration through numerous proven UX principles.
The MIT License (MIT) Copyright (c) 2015 Arthur Khachatryan Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Uptime
Get events and metrics from your app in real time to
To beging capturing metrics and events see the Uptime.com documentation at:
https://support.uptime.com/hc/en-us/articles/115002536629-Configuring-Datadog.
You will need to enter the following values when setting up the integration at Uptime.com:
API Key: xxxxx
Application Key: xxxxx


Below you can find the declared Vertex Types with the number of defined properties in parentheses. Click on the type on the left to
display it
properties and indexes.
Below you can find the declared Edge Types with the number of defined properties in parentheses. Click on the type on the left to
display it
properties and indexes.
Below you can find the declared Document Types with the number of defined properties in parentheses. Click on the type on the left to
display
it properties and indexes.


FIZ(1) FIZ(1) NAME fiz - analyze damaged zoo archive for data recovery SYNOPSIS fiz archive[.zoo] DESCRIPTION Fiz is used to analyze damaged zoo archives and locate directory entries and file data in them. The current version of fiz is 2.0 and it is meant to be used in conjunction with zoo version 2.0. Fiz makes no assumptions about archive structure. Instead, it simply searches the entire subject archive for tag values that mark the locations of directory entries and file data. In a zoo archive, a directory entry contains information about a stored file such as its name, whether compressed or not, and its timestamp. The file data are the actual data for the archived file, and may be either the original data, or the result of compressing the file. For each directory entry found, fiz prints where in the archive it is located, the directory path and filename(s) found in it, whether the directory entry appears to be corrupted (indicated by [*CRC Error*]), and the value of the pointer to the file data that is found in the directory entry. For each block of file data found in the archive, fiz prints where in the archive the block begins. In the case of an undamaged ar‐ chive, the pointer to file data found in a directory entry will corre‐ spond to where fiz actually locates the data. Here is some sample output from fiz: **************** 2526: DIR [changes] ==> 95 2587: DATA **************** 3909: DIR [copyrite] ==> 1478 3970: DATA 4769: DATA **************** In such output, DIR indicates where fiz found a directory entry in the archive, and DATA indicates where fiz found file data in the archive. Filenames located by fiz are enclosed in square brackets, and the nota‐ tion "==> 95" indicates that the directory entry found by fiz at posi‐ tion 2526 has a file data pointer to position 95. In actuality, fiz found file data at positions 2587, 3970, and 4769. Since fiz found only two directory entries, and each directory entry corresponds to one file, one of the file data positions is an artifact. Once the locations of directory entries and file data are found, the @ modifier to zoo's archive list and extract commands can be used and the archive contents selectively listed or extracted, skipping the damaged portion. This is further described in the documentation for zoo(1). In the above case, commands to try giving to zoo might be x@2526,2587 (extract beginning at position 2526, and get file data from position 2587), x@3090,3970 (extract at 3090, get data from 3970) and x@3909,4769 (extract at 3909, get data from 4769). Once a correctly-matched direc‐ tory entry/file data pair is found, zoo will in most cases synchronize with and correctly extract all files subsequently found in the archive. Trial and error should allow all undamaged files to be extracted. Also note that self-extracting archives created using sez (the Self-Extracting Zoo utility for MS-DOS), which are normally executed on an MS-DOS system for extraction, can be extracted on non-MSDOS systems in a similar way. SEE ALSO zoo(1) BUGS Random byte patterns can occasionally be incorrectly recognized as tag values. This occurs very rarely, however, and trial and error will usu‐ ally permit all undamaged data to be extracted. DIAGNOSTICS Fiz always exits with a status code of 0. FUTURE DIRECTIONS Automation of data recovery from a damaged archive is potentially achiev‐ able. However, since damaged archives occur only rarely, fiz as it cur‐ rently stands is unlikely to change much in the near future. AUTHOR Rahul Dhesi Jan 31, 1988 FIZ(1)


Bagnetto with bitter crudités recipe
by Catherine PhippsThe flavour of this dip is incredible – richly savoury, spicy, salty, tinged with sweetness – the best way to completely satisfy the palate is to serve it with something succulent and bitter.
Prep time: 10 minutes
SERVES
Four
INGREDIENTS
- 40g flat leaf parsley
- A few sprigs each of tarragon, basil and chervil (optional)
- 50g capers
- A few caper leaves (optional)
- 1 small tin of anchovies and their oil
- 2 tbsp Dijon mustard
- 2 tbsp tomato purée
- 1 tbsp red wine vinegar
- 1 tsp dried thyme or a few dried thyme flower heads
- ½ tsp chilli flakes, plus a little more to taste, if desired
- ½ tsp freshly ground white pepper
- 4 tbsp olive oil
- A pinch of caster sugar (optional)
- Sea salt (optional)
To serve
- A few heads of Belgian endive, separated into leaves, or cut into thin wedges, or any other kind of crisp winter leaves, such as slender, curling tardivo (fiori d’Inverno) or puntarelle.
METHOD
- Finely chop all the herbs, capers, caper leaves, if using, and the anchovies.
- Put in a bowl and add the mustard, tomato purée, vinegar, thyme, chilli flakes and white pepper. Stir to combine, then whisk in the olive oil.
- Leave to stand for a few minutes, then taste. If you haven’t used the sweeter herbs you may need to add a pinch of sugar, and if you haven’t used salted capers or anchovies, you may want to add salt.
- Adjust according to your taste and transfer to a serving bowl, or for future use, a sterilised jar.
- Arrange the endives on a platter and serve with the dip. If you have any left, store in a sterilised jar in the fridge, covered with a little olive oil.
Leaf: Lettuce, Greens, Herbs, Weeds by Catherine Phipps, is published by Quadrille (£25). Order your copy from books.telegraph.co.uk


WITNESS LIST Appropriations-S/C on Education Committee February 9, 1999-8:00A Budget For: Green, Ray (Parker College of Chiropractic) McDonald, Carol (Independent Colleges & Universities of Texas) Parker, Carl (Parker College of Chiropractic) Schulle, Gerhardt (Texas Society of Professional Engineers) Swindle, Jack (Texas Instruments) On: Anderson, T. Chaney (U of Houston - Downtown) Angel, Dan (Stephen F. Austin University) Ashley, Janelle (Stephen F. Austin University) Berry, Wilkes (Texas Woman's University) Brown, Don (Coordinating Board) Byers-Pevitts, Beverley (Texas Woman's University) Castillo, Max (U of Houston - Downtown) Cohen, Dr. Benjamin (U of North Texas Health Science Center) Cunningham, Bill (U of Texas System) DeBakey, Michael (Baylor College of Medicine) Feigin, Ralph (Baylor College of Medicine) Floyd, Brenda (Texas Woman's University) Gonzalez, Adela (U of North Texas Health Science Center) Goodman, Kay (Texas Woman's University) Hardy, James (Stephen F. Austin University) Haynes, Karen (U of Houston - Victoria) Hurley, Alfred (U of North Texas) McWhorter, James (Coordinating Board) Montford, John (Texas Tech University) Richards, David (U of North Texas Health Science Center) Sanford, William (Coordinating Board) Sayavedra, Leo (Texas A&M System) Smith, Arthur (U of Houston System) Smith, Roland (Stephen F. Austin University) Staples, William (U of Houston - Clear Lake) Walker, Kay (U of Houston System) Willeford, Pamela (Coordinating Board)


[t]Dear {$r.candidate_name}[/t]
[t]Your CV and registration is requested by {$r.buyer_name}. This interesting opportunity could be a chance for yourself. Please use the following link to accept or reject the offer (or to get yourself removed from our search database in case you do not want to receive any further offers).[/t]
[t]Click here to continue by accepting or rejecting the offer[/t]
[t]Kind regards[/t]
{if ('' !== $seller_consultant_name)}
{$seller_consultant_name}
{/if}
{$r.seller_name}


createsdk - release legato project
Once Legato tools have been built this script stages files and produces a tarball.
Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.


I'm not able to recreate this issue. Not in Mozilla Firefox or Google Chrome, I even tried with an Xbox account and with the theme on.
Has this issue occurred many times for you or is this the first time?
juress
Theme Developer
Clear your cache and net temp files.
BrainFooLong
Administrator
This ain't a bug for BBLog, it's theme issue.
Moved.
juress
Theme Developer
brain wrote:
This ain't a bug for BBLog, it's theme issue.
Moved.
Its not a theme issue.
BrainFooLong
Administrator
I don't really see any bug except that some numbers not visible because of wrong colors.
Anyway, not a BBLog bug because BBLog doesn't change anything on this page.
BrainFooLong
Administrator
PS: Now i see whats the problem. Anyway, not BBLog related and NOT theme related. Moved again.


--- title: 404 description: Uh Oh layout: docwithnav permalink: /404.html ---
Sorry, this page doens't exist.
Calico documentation has moved around quite a bit lately.
If you are looking for a page on the old 'docs.projectcalico.org', they have been moved to http://docs-archive.projectcalico.org
If you are looking for something else, let us know on slack! It's possible a doc should be here, and needs to be recovered.


There are a number of ways to contact the development team.
You can shoot us an email, leave a message on our development thread
or drop by our GitHub where you can help us make OpenSprites even better for everyone!
If you have any questions, feel free to ask on our forums.