drduh/macOS-Security-and-Privacy-Guide: A practical guide to securing macOS. - 1 views
-
crazylion lee on 27 Nov 16"A practical guide to securing macOS."
水平擴展儲存空間
Group items tagged
The TCP/IP Guide - Introduction To The TCP/IP Guide - 0 views
SQL style guide by Simon Holywell - 0 views
The Storyteller's Guide to the Virtual Reality Audience - Stanford d.school - Medium - 0 views
[Elasticsearch] 分散式特性 & 分散式搜尋的機制 | 小信豬的原始部落 - 0 views
-
-
Data HA：若有 node 掛掉，資料不會遺失
-
若是要查詢 cluster 中的 node 狀態，可以使用 GET /_cat/nodes API
- ...39 more annotations...
-
決定每個 shard 要被分配到哪個 data node 上
-
為 cluster 設置多個 master node
-
一旦發現被選中的 master node 出現問題，就會選出新的 master node
-
每個 node 啟動時就預設是一個 master eligible node，可以透過設定 node.master: false 取消此預設設定
-
處理 request 的 node 稱為 Coordinating Node，其功能是將 request 轉發到合適的 node 上
-
所有的 node 都預設是 Coordinating Node
-
coordinating node 可以直接接收 search request 並處理，不需要透過 master node 轉過來
-
可以保存資料的 node，每個 node 啟動後都會預設是 data node，可以透過設定 node.data: false 停用 data node 功能
-
由 master node 決定如何把分片分發到不同的 data node 上
-
每個 node 上都保存了 cluster state
-
只有 master 才可以修改 cluster state 並負責同步給其他 node
-
每個 node 都會詳細紀錄本身的狀態資訊
-
shard 是 Elasticsearch 分散式儲存的基礎，包含 primary shard & replica shard
-
每一個 shard 就是一個 Lucene instance
-
primary shard 功能是將一份被索引後的資料，分散到多個 data node 上存放，實現儲存方面的水平擴展
-
primary shard 的數量在建立 index 時就會指定，後續是無法修改的，若要修改就必須要進行 reindex
-
當 primary shard 遺失時，replica shard 就可以被 promote 成 primary shard 來保持資料完整性
-
replica shard 數量可以動態調整，讓每個 data node 上都有完整的資料
-
ES 7.0 開始，primary shard 預設為 1，replica shard 預設為 0
-
replica shard 若設定過多，會降低 cluster 整體的寫入效能
-
replica shard 必須和 primary shard 被分配在不同的 data node 上
-
所有的 primary shard 可以在同一個 data node 上
-
透過 GET _cluster/health/<target> 可以取得目前 cluster 的健康狀態
-
Yellow：表示 primary shard 可以正常分配，但 replica shard 分配有問題
-
透過 GET /_cat/shards/<target> 可以取得目前的 shard 狀態
-
replica shard 無法被分配，因此 cluster 健康狀態為黃色
-
若是擔心 reboot 機器造成 failover 動作開始執行，可以設定將 replication 延遲一段時間後再執行(透過調整 settings 中的 index.unassigned.node_left.delayed_timeout 參數)，避免無謂的 data copy 動作 (此功能稱為 delay allocation)
-
集群變紅，代表有 primary shard 丟失，這個時候會影響讀寫。
-
如果 node 重新回來，會從 translog 中恢復沒有寫入的資料
-
設定 index settings 之後，primary shard 數量無法隨意變更
-
不建議直接發送請求到master節點，雖然也會工作，但是大量請求發送到 master，會有潛在的性能問題
-
shard 是 ES 中最小的工作單元
-
shard 是一個 Lucene 的 index
-
將 Index Buffer 中的內容寫入 Segment，而這寫入的過程就稱為 Refresh
-
當 document 被 refresh 進入到 segment 之後，就可以被搜尋到了
-
在進行 refresh 時先將 segment 寫入 cache 以開放查詢
-
將 document 進行索引時，同時也會寫入 transaction log，且預設都會寫入磁碟中
-
每個 shard 都會有對應的 transaction log
-
由於 transaction log 都會寫入磁碟中，因此當 node 從故障中恢復時，就會優先讀取 transaction log 來恢復資料
A Guide to Testing Rails Applications - Ruby on Rails Guides - 0 views
-
Rails tests can also simulate browser requests and thus you can test your application's response without having to test it through your browser.
-
your tests will need a database to interact with as well.
-
By default, every Rails application has three environments: development, test, and production
- ...25 more annotations...
-
models directory is meant to hold tests for your models
-
controllers directory is meant to hold tests for your controllers
-
integration directory is meant to hold tests that involve any number of controllers interacting
-
Fixtures are a way of organizing test data; they reside in the fixtures folder
-
The test_helper.rb file holds the default configuration for your tests
-
Fixtures allow you to populate your testing database with predefined data before your tests run
-
Fixtures are database independent written in YAML.
-
one file per model.
-
Each fixture is given a name followed by an indented list of colon-separated key/value pairs.
-
Keys which resemble YAML keywords such as 'yes' and 'no' are quoted so that the YAML Parser correctly interprets them.
-
define a reference node between two different fixtures.
-
ERB allows you to embed Ruby code within templates
-
The YAML fixture format is pre-processed with ERB when Rails loads fixtures.
-
Rails by default automatically loads all fixtures from the test/fixtures folder for your models and controllers test.
-
Fixtures are instances of Active Record.
-
access the object directly
-
test_helper.rb specifies the default configuration to run our tests. This is included with all the tests, so any methods added to this file are available to all your tests.
-
test with method names prefixed with test_.
-
An assertion is a line of code that evaluates an object (or expression) for expected results.
-
bin/rake db:test:prepare
-
Every test contains one or more assertions. Only when all the assertions are successful will the test pass.
-
rake test command
-
run a particular test method from the test case by running the test and providing the test method name.
-
The . (dot) above indicates a passing test. When a test fails you see an F; when a test throws an error you see an E in its place.
-
we first wrote a test which fails for a desired functionality, then we wrote some code which adds the functionality and finally we ensured that our test passes. This approach to software development is referred to as Test-Driven Development (TDD).
Computer Science Field Guide - Computer Science Field Guide - 0 views
www.csfieldguide.org.nz/...index.html
computer computer science science guide field google algorithm
shared by crazylion lee on 21 Jun 16
- No Cached
-
"An online interactive resource for high school students learning about computer science"
A Comprehensive Guide To Debugging Rails | Jack Kinsella - Analyst Berlin - 0 views
The Rails Command Line - Ruby on Rails Guides - 0 views
-
rake --tasks
-
Think of destroy as the opposite of generate.
-
runner runs Ruby code in the context of Rails non-interactively
- ...28 more annotations...
-
rails dbconsole figures out which database you're using and drops you into whichever command line interface you would use with it
-
The console command lets you interact with your Rails application from the command line. On the underside, rails console uses IRB
-
rake about gives information about version numbers for Ruby, RubyGems, Rails, the Rails subcomponents, your application's folder, the current Rails environment name, your app's database adapter, and schema version
-
You can precompile the assets in app/assets using rake assets:precompile and remove those compiled assets using rake assets:clean.
-
rake db:version is useful when troubleshooting
-
The doc: namespace has the tools to generate documentation for your app, API documentation, guides.
-
rake notes will search through your code for comments beginning with FIXME, OPTIMIZE or TODO.
-
You can also use custom annotations in your code and list them using rake notes:custom by specifying the annotation using an environment variable ANNOTATION.
-
rake routes will list all of your defined routes, which is useful for tracking down routing problems in your app, or giving you a good overview of the URLs in an app you're trying to get familiar with.
-
rake secret will give you a pseudo-random key to use for your session secret.
-
Custom rake tasks have a .rake extension and are placed in Rails.root/lib/tasks.
-
rails new . --git --database=postgresql
-
All commands can run with -h or --help to list more information
-
The rails server command launches a small web server named WEBrick which comes bundled with Ruby
-
rails server -e production -p 4000
-
You can run a server as a daemon by passing a -d option
-
The rails generate command uses templates to create a whole lot of things.
-
Using generators will save you a large amount of time by writing boilerplate code, code that is necessary for the app to work.
-
All Rails console utilities have help text.
-
generate controller ControllerName action1 action2.
-
With a normal, plain-old Rails application, your URLs will generally follow the pattern of http://(host)/(controller)/(action), and a URL like http://(host)/(controller) will hit the index action of that controller.
-
A scaffold in Rails is a full set of model, database migration for that model, controller to manipulate it, views to view and manipulate the data, and a test suite for each of the above.
-
Unit tests are code that tests and makes assertions about code.
-
Unit tests are your friend.
-
rails console --sandbox
-
rails db
-
Each task has a description, and should help you find the thing you need.
-
rake tmp:clear clears all the three: cache, sessions and sockets.
Helm | - 0 views
-
Helm will figure out where to install Tiller by reading your Kubernetes configuration file (usually $HOME/.kube/config). This is the same file that kubectl uses.
-
kubectl cluster-info
-
Role-Based Access Control (RBAC) enabled
- ...133 more annotations...
-
initialize the local CLI
-
install Tiller into your Kubernetes cluster
-
helm install
-
helm init --upgrade
-
By default, when Tiller is installed, it does not have authentication enabled.
-
helm repo update
-
Without a max history set the history is kept indefinitely, leaving a large number of records for helm and tiller to maintain.
-
helm init --upgrade
-
Whenever you install a chart, a new release is created.
-
one chart can be installed multiple times into the same cluster. And each can be independently managed and upgraded.
-
helm list function will show you a list of all deployed releases.
-
helm delete
-
helm status
-
you can audit a cluster’s history, and even undelete a release (with helm rollback).
-
the Helm server (Tiller).
-
The Helm client (helm)
-
brew install kubernetes-helm
-
Tiller, the server portion of Helm, typically runs inside of your Kubernetes cluster.
-
it can also be run locally, and configured to talk to a remote Kubernetes cluster.
-
Role-Based Access Control - RBAC for short
-
create a service account for Tiller with the right roles and permissions to access resources.
-
run Tiller in an RBAC-enabled Kubernetes cluster.
-
run kubectl get pods --namespace kube-system and see Tiller running.
-
helm inspect
-
Helm will look for Tiller in the kube-system namespace unless --tiller-namespace or TILLER_NAMESPACE is set.
-
For development, it is sometimes easier to work on Tiller locally, and configure it to connect to a remote Kubernetes cluster.
-
even when running locally, Tiller will store release configuration in ConfigMaps inside of Kubernetes.
-
helm version should show you both the client and server version.
-
Tiller stores its data in Kubernetes ConfigMaps, you can safely delete and re-install Tiller without worrying about losing any data.
-
helm reset
-
The --node-selectors flag allows us to specify the node labels required for scheduling the Tiller pod.
-
--override allows you to specify properties of Tiller’s deployment manifest.
-
helm init --override manipulates the specified properties of the final manifest (there is no “values” file).
-
The --output flag allows us skip the installation of Tiller’s deployment manifest and simply output the deployment manifest to stdout in either JSON or YAML format.
-
By default, tiller stores release information in ConfigMaps in the namespace where it is running.
-
switch from the default backend to the secrets backend, you’ll have to do the migration for this on your own.
-
a beta SQL storage backend that stores release information in an SQL database (only postgres has been tested so far).
-
Once you have the Helm Client and Tiller successfully installed, you can move on to using Helm to manage charts.
-
Helm requires that kubelet have access to a copy of the socat program to proxy connections to the Tiller API.
-
A Release is an instance of a chart running in a Kubernetes cluster. One chart can often be installed many times into the same cluster.
-
helm init --client-only
-
helm init --dry-run --debug
-
A panic in Tiller is almost always the result of a failure to negotiate with the Kubernetes API server
-
Tiller and Helm have to negotiate a common version to make sure that they can safely communicate without breaking API assumptions
-
helm delete --purge
-
Helm stores some files in $HELM_HOME, which is located by default in ~/.helm
-
A Chart is a Helm package. It contains all of the resource definitions necessary to run an application, tool, or service inside of a Kubernetes cluster.
-
it like the Kubernetes equivalent of a Homebrew formula, an Apt dpkg, or a Yum RPM file.
-
A Repository is the place where charts can be collected and shared.
-
Set the $HELM_HOME environment variable
-
each time it is installed, a new release is created.
-
Helm installs charts into Kubernetes, creating a new release for each installation. And to find new charts, you can search Helm chart repositories.
-
chart repository is named stable by default
-
helm search shows you all of the available charts
-
helm inspect
-
To install a new package, use the helm install command. At its simplest, it takes only one argument: The name of the chart.
-
If you want to use your own release name, simply use the --name flag on helm install
-
additional configuration steps you can or should take.
-
Helm does not wait until all of the resources are running before it exits. Many charts require Docker images that are over 600M in size, and may take a long time to install into the cluster.
-
helm status
-
helm inspect values
-
helm inspect values stable/mariadb
-
override any of these settings in a YAML formatted file, and then pass that file during installation.
-
helm install -f config.yaml stable/mariadb
-
--values (or -f): Specify a YAML file with overrides.
-
--set (and its variants --set-string and --set-file): Specify overrides on the command line.
-
Values that have been --set can be cleared by running helm upgrade with --reset-values specified.
-
Chart designers are encouraged to consider the --set usage when designing the format of a values.yaml file.
-
--set-file key=filepath is another variant of --set. It reads the file and use its content as a value.
-
inject a multi-line text into values without dealing with indentation in YAML.
-
An unpacked chart directory
-
When a new version of a chart is released, or when you want to change the configuration of your release, you can use the helm upgrade command.
-
Kubernetes charts can be large and complex, Helm tries to perform the least invasive upgrade.
-
It will only update things that have changed since the last release
-
$ helm upgrade -f panda.yaml happy-panda stable/mariadb
-
deployment
-
If both are used, --set values are merged into --values with higher precedence.
-
The helm get command is a useful tool for looking at a release in the cluster.
-
helm rollback
-
A release version is an incremental revision. Every time an install, upgrade, or rollback happens, the revision number is incremented by 1.
-
helm history
-
a release name cannot be re-used.
-
you can rollback a deleted resource, and have it re-activate.
-
helm repo list
-
helm repo add
-
helm repo update
-
The Chart Development Guide explains how to develop your own charts.
-
helm create
-
helm lint
-
helm package
-
Charts that are archived can be loaded into chart repositories.
-
chart repository server
-
Tiller can be installed into any namespace.
-
Limiting Tiller to only be able to install into specific namespaces and/or resource types is controlled by Kubernetes RBAC roles and rolebindings
-
Release names are unique PER TILLER INSTANCE
-
Charts should only contain resources that exist in a single namespace.
-
not recommended to have multiple Tillers configured to manage resources in the same namespace.
-
a client-side Helm plugin. A plugin is a tool that can be accessed through the helm CLI, but which is not part of the built-in Helm codebase.
-
Helm plugins are add-on tools that integrate seamlessly with Helm. They provide a way to extend the core feature set of Helm, but without requiring every new feature to be written in Go and added to the core tool.
-
Helm plugins live in $(helm home)/plugins
-
The Helm plugin model is partially modeled on Git’s plugin model
-
helm referred to as the porcelain layer, with plugins being the plumbing.
-
helm plugin install https://github.com/technosophos/helm-template
-
command is the command that this plugin will execute when it is called.
-
Environment variables are interpolated before the plugin is executed.
-
The command itself is not executed in a shell. So you can’t oneline a shell script.
-
Helm is able to fetch Charts using HTTP/S
-
Variables like KUBECONFIG are set for the plugin if they are set in the outer environment.
-
In Kubernetes, granting a role to an application-specific service account is a best practice to ensure that your application is operating in the scope that you have specified.
-
restrict Tiller’s capabilities to install resources to certain namespaces, or to grant a Helm client running access to a Tiller instance.
-
Service account with cluster-admin role
-
The cluster-admin role is created by default in a Kubernetes cluster
-
Deploy Tiller in a namespace, restricted to deploying resources only in that namespace
-
Deploy Tiller in a namespace, restricted to deploying resources in another namespace
-
When running a Helm client in a pod, in order for the Helm client to talk to a Tiller instance, it will need certain privileges to be granted.
-
SSL Between Helm and Tiller
-
The Tiller authentication model uses client-side SSL certificates.
-
creating an internal CA, and using both the cryptographic and identity functions of SSL.
-
Helm is a powerful and flexible package-management and operations tool for Kubernetes.
-
default installation applies no security configurations
-
with a cluster that is well-secured in a private network with no data-sharing or no other users or teams.
-
With great power comes great responsibility.
-
Choose the Best Practices you should apply to your helm installation
-
Role-based access control, or RBAC
-
Tiller’s gRPC endpoint and its usage by Helm
-
Kubernetes employ a role-based access control (or RBAC) system (as do modern operating systems) to help mitigate the damage that can be done if credentials are misused or bugs exist.
-
In the default installation the gRPC endpoint that Tiller offers is available inside the cluster (not external to the cluster) without authentication configuration applied.
-
Tiller stores its release information in ConfigMaps. We suggest changing the default to Secrets.
-
release information
-
charts
-
charts are a kind of package that not only installs containers you may or may not have validated yourself, but it may also install into more than one namespace.
-
As with all shared software, in a controlled or shared environment you must validate all software you install yourself before you install it.
-
Helm’s provenance tools to ensure the provenance and integrity of charts
-
"Helm will figure out where to install Tiller by reading your Kubernetes configuration file (usually $HOME/.kube/config). This is the same file that kubectl uses."
bbatsov/rails-style-guide: A community-driven Ruby on Rails 4 style guide - 0 views
-
custom initialization code in config/initializers. The code in initializers executes on application startup
-
Keep initialization code for each gem in a separate file with the same name as the gem
-
Mark additional assets for precompilation
- ...90 more annotations...
-
config/environments/production.rb
-
Create an additional staging environment that closely resembles the production one
-
Keep any additional configuration in YAML files under the config/ directory
-
Rails::Application.config_for(:yaml_file)
-
Use nested routes to express better the relationship between ActiveRecord models
-
nest routes more than 1 level deep then use the shallow: true option
-
namespaced routes to group related actions
-
Don't use match to define any routes unless there is need to map multiple request types among [:get, :post, :patch, :put, :delete] to a single action using :via option.
-
Keep the controllers skinny
-
all the business logic should naturally reside in the model
-
Share no more than two instance variables between a controller and a view.
-
using a template
-
Prefer render plain: over render text
-
Prefer corresponding symbols to numeric HTTP status codes
-
without abbreviations
-
Keep your models for business logic and data-persistence only
-
Avoid altering ActiveRecord defaults (table names, primary key, etc)
-
Group macro-style methods (has_many, validates, etc) in the beginning of the class definition
-
Prefer has_many :through to has_and_belongs_to_many
-
self[:attribute]
-
self[:attribute] = value
-
validates
-
Keep custom validators under app/validators
-
Consider extracting custom validators to a shared gem
-
preferable to make a class method instead which serves the same purpose of the named scope
-
returns an ActiveRecord::Relation object
-
.update_attributes
-
Override the to_param method of the model
-
Use the friendly_id gem. It allows creation of human-readable URLs by using some descriptive attribute of the model instead of its id
-
find_each to iterate over a collection of AR objects
-
.find_each
-
.find_each
-
Looping through a collection of records from the database (using the all method, for example) is very inefficient since it will try to instantiate all the objects at once
-
always call before_destroy callbacks that perform validation with prepend: true
-
Define the dependent option to the has_many and has_one associations
-
always use the exception raising bang! method or handle the method return value.
-
When persisting AR objects
-
Avoid string interpolation in queries
-
param will be properly escaped
-
Consider using named placeholders instead of positional placeholders
-
use of find over where when you need to retrieve a single record by id
-
use of find_by over where and find_by_attribute
-
use of where.not over SQL
-
use heredocs with squish
-
Keep the schema.rb (or structure.sql) under version control.
-
Use rake db:schema:load instead of rake db:migrate to initialize an empty database
-
Enforce default values in the migrations themselves instead of in the application layer
-
change_column_default
-
imposing data integrity from the Rails app is impossible
-
use the change method instead of up and down methods.
-
constructive migrations
-
use models in migrations, make sure you define them so that you don't end up with broken migrations in the future
-
Don't use non-reversible migration commands in the change method.
-
In this case, block will be used by create_table in rollback
-
Never call the model layer directly from a view
-
Never make complex formatting in the views, export the formatting to a method in the view helper or the model.
-
When the labels of an ActiveRecord model need to be translated, use the activerecord scope
-
Separate the texts used in the views from translations of ActiveRecord attributes
-
Place the locale files for the models in a folder locales/models
-
the texts used in the views in folder locales/views
-
config/application.rb config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]
-
I18n.t
-
I18n.l
-
Use "lazy" lookup for the texts used in views.
-
Use the dot-separated keys in the controllers and models
-
Reserve app/assets for custom stylesheets, javascripts, or images
-
Third party code such as jQuery or bootstrap should be placed in vendor/assets
-
Provide both HTML and plain-text view templates
-
config.action_mailer.raise_delivery_errors = true
-
Use a local SMTP server like Mailcatcher in the development environment
-
Provide default settings for the host name
-
The _url methods include the host name and the _path methods don't
-
_url
-
Format the from and to addresses properly
-
default from:
-
sending html emails all styles should be inline
-
Sending emails while generating page response should be avoided. It causes delays in loading of the page and request can timeout if multiple email are sent.
-
.start_with?
-
.end_with?
-
&.
-
Config your timezone accordingly in application.rb
-
config.active_record.default_timezone = :local
-
it can be only :utc or :local
-
Don't use Time.parse
-
Time.zone.parse
-
Don't use Time.now
-
Time.zone.now
-
Put gems used only for development or testing in the appropriate group in the Gemfile
-
Add all OS X specific gems to a darwin group in the Gemfile, and all Linux specific gems to a linux group
-
Do not remove the Gemfile.lock from version control.
mvn clean install - a short guide to Maven - 0 views
-
An equivalent in other languages would be Javascript’s npm, Ruby’s gems or PHP’s composer.
-
Maven expects a certain directory structure for your Java source code to live in and when you later do a mvn clean install , the whole compilation and packaging work will be done for you.
-
any directory that contains a pom.xml file is also a valid Maven project.
- ...17 more annotations...
-
A pom.xml file contains everything needed to describe your Java project.
-
Java source code is to be meant to live in the "/src/main/java" folder
-
Maven will put compiled Java classes into the "target/classes" folder
-
Maven will also build a .jar or .war file, depending on your project, that lives in the "target" folder.
-
Maven has the concept of a build lifecycle, which is made up of different phases.
-
clean is not part of Maven’s default lifecycle, you end up with commands like mvn clean install or mvn clean package. Install or package will trigger all preceding phases, but you need to specify clean in addition.
-
Maven will always download your project dependencies into your local maven repository first and then reference them for your build.
-
local repositories (in your user’s home directory: ~/.m2/)
-
clean: deletes the /target folder.
-
mvn clean package
-
mvn clean install
-
package: Converts your .java source code into a .jar/.war file and puts it into the /target folder.
-
install: First, it does a package(!). Then it takes that .jar/.war file and puts it into your local Maven repository, which lives in ~/.m2/repository.
-
calling 'mvn install' would be enough if Maven was smart enough to do reliable, incremental builds.
-
figuring out what Java source files/modules changed and only compile those.
-
developers got it ingrained to always call 'mvn clean install' (even though this increases build time a lot in bigger projects).
-
make sure that Maven always tries to download the latest snapshot dependency versions
Working with JavaScript in Rails - Ruby on Rails Guides - 0 views
-
JavaScript can also make requests to the server, and parse the response
-
Rails uses a technique called "Unobtrusive JavaScript" to handle attaching JavaScript to the DOM.
-
We call this 'unobtrusive' JavaScript because we're no longer mixing our JavaScript into our HTML.
- ...2 more annotations...
-
the data-remote="true". Now, the form will be submitted by Ajax rather than by the browser's normal submit mechanism.
-
the format.js in the respond_to block; that allows the controller to respond to your Ajax request.
Active Record Migrations - Ruby on Rails Guides - 0 views
-
each migration as being a new 'version' of the database.
-
A schema starts off with nothing in it, and each migration modifies it to add or remove tables, columns, or entries
-
Active Record will also update your db/schema.rb file to match the up-to-date structure of your database.
- ...14 more annotations...
-
The timestamps macro adds two columns, created_at and updated_at.
-
A primary key column called id will also be added implicitly, as it's the default primary key for all Active Record models
-
On databases that support transactions with statements that change the schema, migrations are wrapped in a transaction
-
If the database does not support this then when a migration fails the parts of it that succeeded will not be rolled back. You will have to rollback the changes that were made by hand.
-
If your adapter supports DDL transactions you can use disable_ddl_transaction! to disable them for a single migration
-
reversible
-
AddXXXToYYY
-
RemoveXXXFromYYY
-
Migrations are stored as files in the db/migrate directory, one for each migration class
-
a UTC timestamp identifying the migration followed by an underscore followed by the name of the migration.
-
The name of the migration class (CamelCased version) should match the latter part of the file name
-
add_details_to_products.rb should define AddDetailsToProducts
-
create_products.rb should define class CreateProducts
-
Rails uses this timestamp to determine which migration should be run and in what order,
JavaScript Standard Style - 0 views
A beginners guide to SQL - 0 views
Active Record Associations - Ruby on Rails Guides - 0 views
-
With Active Record associations, we can streamline these - and other - operations by declaratively telling Rails that there is a connection between the two models.
-
belongs_to has_one has_many has_many :through has_one :through has_and_belongs_to_many
-
an association is a connection between two Active Record models
- ...195 more annotations...
-
Associations are implemented using macro-style calls, so that you can declaratively add features to your models
-
A belongs_to association sets up a one-to-one connection with another model, such that each instance of the declaring model "belongs to" one instance of the other model.
-
belongs_to associations must use the singular term.
-
belongs_to
-
A has_one association also sets up a one-to-one connection with another model, but with somewhat different semantics (and consequences).
-
This association indicates that each instance of a model contains or possesses one instance of another model
-
belongs_to
-
A has_many association indicates a one-to-many connection with another model.
-
This association indicates that each instance of the model has zero or more instances of another model.
-
belongs_to
-
A has_many :through association is often used to set up a many-to-many connection with another model
-
This association indicates that the declaring model can be matched with zero or more instances of another model by proceeding through a third model.
-
through:
-
through:
-
The collection of join models can be managed via the API
-
new join models are created for newly associated objects, and if some are gone their rows are deleted.
-
The has_many :through association is also useful for setting up "shortcuts" through nested has_many associations
-
A has_one :through association sets up a one-to-one connection with another model. This association indicates that the declaring model can be matched with one instance of another model by proceeding through a third model.
-
A has_and_belongs_to_many association creates a direct many-to-many connection with another model, with no intervening model.
-
id: false
-
The has_one relationship says that one of something is yours
-
using t.references :supplier instead.
-
declare a many-to-many relationship is to use has_many :through. This makes the association indirectly, through a join model
-
set up a has_many :through relationship if you need to work with the relationship model as an independent entity
-
set up a has_and_belongs_to_many relationship (though you'll need to remember to create the joining table in the database).
-
use has_many :through if you need validations, callbacks, or extra attributes on the join model
-
With polymorphic associations, a model can belong to more than one other model, on a single association.
-
belongs_to :imageable, polymorphic: true
-
a polymorphic belongs_to declaration as setting up an interface that any other model can use.
-
-
-
In designing a data model, you will sometimes find a model that should have a relation to itself
-
add a references column to the model itself
-
Controlling caching Avoiding name collisions Updating the schema Controlling association scope Bi-directional associations
-
All of the association methods are built around caching, which keeps the result of the most recent query available for further operations.
-
it is a bad idea to give an association a name that is already used for an instance method of ActiveRecord::Base. The association method would override the base method and break things.
-
You are responsible for maintaining your database schema to match your associations.
-
belongs_to associations you need to create foreign keys
-
has_and_belongs_to_many associations you need to create the appropriate join table
-
If you create an association some time after you build the underlying model, you need to remember to create an add_column migration to provide the necessary foreign key.
-
Active Record creates the name by using the lexical order of the class names
-
So a join between customer and order models will give the default join table name of "customers_orders" because "c" outranks "o" in lexical ordering.
-
For example, one would expect the tables "paper_boxes" and "papers" to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes", but it in fact generates a join table name of "paper_boxes_papers" (because the underscore '' is lexicographically _less than 's' in common encodings).
-
id: false
-
pass id: false to create_table because that table does not represent a model
-
By default, associations look for objects only within the current module's scope.
-
will work fine, because both the Supplier and the Account class are defined within the same scope.
-
To associate a model with a model in a different namespace, you must specify the complete class name in your association declaration:
-
class_name
-
class_name
-
Active Record provides the :inverse_of option
-
-
-
preventing inconsistencies and making your application more efficient
-
Every association will attempt to automatically find the inverse association and set the :inverse_of option heuristically (based on the association name)
-
In database terms, this association says that this class contains the foreign key.
-
In all of these methods, association is replaced with the symbol passed as the first argument to belongs_to.
-
(force_reload = false)
-
The association method returns the associated object, if any. If no associated object is found, it returns nil.
-
the cached version will be returned.
-
The association= method assigns an associated object to this object.
-
Behind the scenes, this means extracting the primary key from the associate object and setting this object's foreign key to the same value.
-
The build_association method returns a new object of the associated type
-
but the associated object will not yet be saved.
-
The create_association method returns a new object of the associated type
-
once it passes all of the validations specified on the associated model, the associated object will be saved
-
raises ActiveRecord::RecordInvalid if the record is invalid.
-
dependent
-
counter_cache
-
:autosave :class_name :counter_cache :dependent :foreign_key :inverse_of :polymorphic :touch :validate
-
finding the number of belonging objects more efficient.
-
Although the :counter_cache option is specified on the model that includes the belongs_to declaration, the actual column must be added to the associated model.
-
add a column named orders_count to the Customer model.
-
:destroy, when the object is destroyed, destroy will be called on its associated objects.
-
deleted directly from the database without calling their destroy method.
-
Rails will not create foreign key columns for you
-
The :inverse_of option specifies the name of the has_many or has_one association that is the inverse of this association
-
set the :touch option to :true, then the updated_at or updated_on timestamp on the associated object will be set to the current time whenever this object is saved or destroyed
-
specify a particular timestamp attribute to update
-
If you set the :validate option to true, then associated objects will be validated whenever you save this object
-
By default, this is false: associated objects will not be validated when this object is saved.
-
where includes readonly select
-
make your code somewhat more efficient
-
no need to use includes for immediate associations
-
will be read-only when retrieved via the association
-
The select method lets you override the SQL SELECT clause that is used to retrieve data about the associated object
-
using the association.nil?
-
Assigning an object to a belongs_to association does not automatically save the object. It does not save the associated object either.
-
In database terms, this association says that the other class contains the foreign key.
-
the cached version will be returned.
-
:as :autosave :class_name :dependent :foreign_key :inverse_of :primary_key :source :source_type :through :validate
-
Setting the :as option indicates that this is a polymorphic association
-
:nullify causes the foreign key to be set to NULL. Callbacks are not executed.
-
It's necessary not to set or leave :nullify option for those associations that have NOT NULL database constraints.
-
The :source_type option specifies the source association type for a has_one :through association that proceeds through a polymorphic association.
-
The :source option specifies the source association name for a has_one :through association.
-
The :through option specifies a join model through which to perform the query
-
more efficient by including representatives in the association from suppliers to accounts
-
When you assign an object to a has_one association, that object is automatically saved (in order to update its foreign key).
-
If either of these saves fails due to validation errors, then the assignment statement returns false and the assignment itself is cancelled.
-
If the parent object (the one declaring the has_one association) is unsaved (that is, new_record? returns true) then the child objects are not saved.
-
If you want to assign an object to a has_one association without saving the object, use the association.build method
-
collection(force_reload = false) collection<<(object, ...) collection.delete(object, ...) collection.destroy(object, ...) collection=(objects) collection_singular_ids collection_singular_ids=(ids) collection.clear collection.empty? collection.size collection.find(...) collection.where(...) collection.exists?(...) collection.build(attributes = {}, ...) collection.create(attributes = {}) collection.create!(attributes = {})
-
In all of these methods, collection is replaced with the symbol passed as the first argument to has_many, and collection_singular is replaced with the singularized version of that symbol.
-
The collection<< method adds one or more objects to the collection by setting their foreign keys to the primary key of the calling model
-
The collection.delete method removes one or more objects from the collection by setting their foreign keys to NULL.
-
objects will be destroyed if they're associated with dependent: :destroy, and deleted if they're associated with dependent: :delete_all
-
The collection.destroy method removes one or more objects from the collection by running destroy on each object.
-
The collection_singular_ids method returns an array of the ids of the objects in the collection.
-
The collection_singular_ids= method makes the collection contain only the objects identified by the supplied primary key values, by adding and deleting as appropriate
-
The default strategy for has_many :through associations is delete_all, and for has_many associations is to set the foreign keys to NULL.
-
The collection.clear method removes all objects from the collection according to the strategy specified by the dependent option
-
uses the same syntax and options as ActiveRecord::Base.find
-
The collection.where method finds objects within the collection based on the conditions supplied but the objects are loaded lazily meaning that the database is queried only when the object(s) are accessed.
-
The collection.build method returns one or more new objects of the associated type. These objects will be instantiated from the passed attributes, and the link through their foreign key will be created, but the associated objects will not yet be saved.
-
The collection.create method returns a new object of the associated type. This object will be instantiated from the passed attributes, the link through its foreign key will be created, and, once it passes all of the validations specified on the associated model, the associated object will be saved.
-
:as :autosave :class_name :dependent :foreign_key :inverse_of :primary_key :source :source_type :through :validate
-
:delete_all causes all the associated objects to be deleted directly from the database (so callbacks will not execute)
-
:nullify causes the foreign keys to be set to NULL. Callbacks are not executed.
-
where includes readonly select
-
:conditions :through :polymorphic :foreign_key
-
By convention, Rails assumes that the column used to hold the primary key of the association is id. You can override this and explicitly specify the primary key with the :primary_key option.
-
The :source option specifies the source association name for a has_many :through association.
-
You only need to use this option if the name of the source association cannot be automatically inferred from the association name.
-
The :source_type option specifies the source association type for a has_many :through association that proceeds through a polymorphic association.
-
The :through option specifies a join model through which to perform the query.
-
has_many :through associations provide a way to implement many-to-many relationships,
-
By default, this is true: associated objects will be validated when this object is saved.
-
where extending group includes limit offset order readonly select uniq
-
If you use a hash-style where option, then record creation via this association will be automatically scoped using the hash
-
The extending method specifies a named module to extend the association proxy.
-
Association extensions
-
The group method supplies an attribute name to group the result set by, using a GROUP BY clause in the finder SQL.
-
has_many :line_items, -> { group 'orders.id' }, through: :orders
-
more efficient by including line items in the association from customers to orders
-
The limit method lets you restrict the total number of objects that will be fetched through an association.
-
The offset method lets you specify the starting offset for fetching objects via an association
-
The order method dictates the order in which associated objects will be received (in the syntax used by an SQL ORDER BY clause).
-
Use the distinct method to keep the collection free of duplicates.
-
mostly useful together with the :through option
-
-> { distinct }
-
.all.inspect
-
If you want to make sure that, upon insertion, all of the records in the persisted association are distinct (so that you can be sure that when you inspect the association that you will never find duplicate records), you should add a unique index on the table itself
-
unique: true
-
Do not attempt to use include? to enforce distinctness in an association.
-
multiple users could be attempting this at the same time
-
checking for uniqueness using something like include? is subject to race conditions
-
When you assign an object to a has_many association, that object is automatically saved (in order to update its foreign key).
-
If any of these saves fails due to validation errors, then the assignment statement returns false and the assignment itself is cancelled.
-
If the parent object (the one declaring the has_many association) is unsaved (that is, new_record? returns true) then the child objects are not saved when they are added
-
All unsaved members of the association will automatically be saved when the parent is saved.
-
assign an object to a has_many association without saving the object, use the collection.build method
-
collection(force_reload = false) collection<<(object, ...) collection.delete(object, ...) collection.destroy(object, ...) collection=(objects) collection_singular_ids collection_singular_ids=(ids) collection.clear collection.empty? collection.size collection.find(...) collection.where(...) collection.exists?(...) collection.build(attributes = {}) collection.create(attributes = {}) collection.create!(attributes = {})
-
If the join table for a has_and_belongs_to_many association has additional columns beyond the two foreign keys, these columns will be added as attributes to records retrieved via that association.
-
Records returned with additional attributes will always be read-only
-
If you require this sort of complex behavior on the table that joins two models in a many-to-many relationship, you should use a has_many :through association instead of has_and_belongs_to_many.
-
aliased as collection.concat and collection.push.
-
The collection.delete method removes one or more objects from the collection by deleting records in the join table
-
not destroy the objects
-
The collection.destroy method removes one or more objects from the collection by running destroy on each record in the join table, including running callbacks.
-
not destroy the objects.
-
The collection.clear method removes every object from the collection by deleting the rows from the joining table.
-
not destroy the associated objects.
-
The collection.find method finds objects within the collection. It uses the same syntax and options as ActiveRecord::Base.find.
-
The collection.where method finds objects within the collection based on the conditions supplied but the objects are loaded lazily meaning that the database is queried only when the object(s) are accessed.
-
The collection.exists? method checks whether an object meeting the supplied conditions exists in the collection.
-
The collection.build method returns a new object of the associated type.
-
the associated object will not yet be saved.
-
the associated object will be saved.
-
The collection.create method returns a new object of the associated type.
-
it passes all of the validations specified on the associated model
-
:association_foreign_key :autosave :class_name :foreign_key :join_table :validate
-
The :foreign_key and :association_foreign_key options are useful when setting up a many-to-many self-join.
-
Rails assumes that the column in the join table used to hold the foreign key pointing to the other model is the name of that model with the suffix _id added.
-
If you set the :autosave option to true, Rails will save any loaded members and destroy members that are marked for destruction whenever you save the parent object.
-
By convention, Rails assumes that the column in the join table used to hold the foreign key pointing to this model is the name of this model with the suffix _id added.
-
By default, this is true: associated objects will be validated when this object is saved.
-
where extending group includes limit offset order readonly select uniq
-
set conditions via a hash
-
In this case, using @parts.assemblies.create or @parts.assemblies.build will create orders where the factory column has the value "Seattle"
-
If you use a hash-style where, then record creation via this association will be automatically scoped using the hash
-
using a GROUP BY clause in the finder SQL.
-
Use the uniq method to remove duplicates from the collection.
-
assign an object to a has_and_belongs_to_many association, that object is automatically saved (in order to update the join table).
-
If any of these saves fails due to validation errors, then the assignment statement returns false and the assignment itself is cancelled.
-
If the parent object (the one declaring the has_and_belongs_to_many association) is unsaved (that is, new_record? returns true) then the child objects are not saved when they are added.
-
If you want to assign an object to a has_and_belongs_to_many association without saving the object, use the collection.build method.
-
Normal callbacks hook into the life cycle of Active Record objects, allowing you to work with those objects at various points
-
define association callbacks by adding options to the association declaration
-
Rails passes the object being added or removed to the callback.
-
stack callbacks on a single event by passing them as an array
-
If a before_add callback throws an exception, the object does not get added to the collection.
-
if a before_remove callback throws an exception, the object does not get removed from the collection
-
extend these objects through anonymous modules, adding new finders, creators, or other methods.
-
order_number
-
use a named extension module
-
proxy_association.owner returns the object that the association is a part of.