each migration as being a new 'version' of the database.
1More
Phoenix - 0 views
-
"A productive web framework that does not compromise speed and maintainability."
1More
Awesome Ruby | LibHunt - 1 views
-
"A collection of awesome Ruby libraries, tools, frameworks and software "
1More
Real Artists Ship - Native Issue Tracking - 1 views
-
"Ship is a new take on issue tracking for software projects with a focus on SPEED!"
17More
Active Record Migrations - Ruby on Rails Guides - 0 views
-
-
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,
45More
Active Record Callbacks - Ruby on Rails Guides - 0 views
-
Active Record provides hooks into this object life cycle so that you can control your application and its data.
-
Callbacks allow you to trigger logic before or after an alteration of an object's state.
-
Callbacks are methods that get called at certain moments of an object's life cycle.
- ...42 more annotations...
-
created
-
saved
-
updated
-
deleted
-
validated
-
loaded
-
use a macro-style class method to register them as callbacks
-
self.name = login.capitalize if name.blank?
-
registered to only fire on certain life cycle events
-
considered good practice to declare callback methods as protected or private
-
all the available Active Record callbacks,
-
after_initialize callback will be called whenever an Active Record object is instantiated, either by directly using new or when a record is loaded from the database
-
after_find callback will be called whenever Active Record loads a record from the database.
-
after_find is called before after_initialize if both are defined
-
after_touch callback will be called whenever an Active Record object is touched.
-
belongs_to :company, touch: true
-
methods trigger callbacks
-
after_find callback is triggered by the following finder methods
-
after_initialize callback is triggered every time a new object of the class is initialized
-
should be used with caution, however, because important business rules and application logic may be kept in callbacks.
-
As you start registering new callbacks for your models, they will be queued for execution
-
The whole callback chain is wrapped in a transaction
-
Callbacks work through model relationships, and can even be defined by them.
-
As with validations, we can also make the calling of a callback method conditional on the satisfaction of a given predicate
-
When using the :if option, the callback won't be executed if the predicate method returns false; when using the :unless option, the callback won't be executed if the predicate method returns true.
-
with a Symbol
-
with a String
-
with a Proc
-
using eval and hence needs to contain valid Ruby code.
-
mix both :if and :unless in the same callback declaration
-
needed to instantiate a new PictureFileCallbacks object, since we declared our callback as an instance method.
-
Active Record makes it possible to create classes that encapsulate the callback methods, so it becomes very easy to reuse them.
-
won't be necessary to instantiate
-
after_commit
-
after_rollback
-
very similar to the after_save callback except that they don't execute until after database changes have either been committed or rolled back
-
delete_picture_file_from_disk
-
after_commit
-
If anything raises an exception after the after_destroy callback is called and the transaction rolls back, the file will have been deleted and the model will be left in an inconsistent state
-
-
-
don't supply the :on option the callback will fire for every action.
-
The after_commit and after_rollback callbacks are guaranteed to be called for all models created, updated, or destroyed within a transaction block.
120More
Active Record Validations - Ruby on Rails Guides - 0 views
-
validates :name, presence: true
-
Validations are used to ensure that only valid data is saved into your database
-
Model-level validations are the best way to ensure that only valid data is saved into your database.
- ...117 more annotations...
-
native database constraints
-
client-side validations
-
controller-level validations
-
Database constraints and/or stored procedures make the validation mechanisms database-dependent and can make testing and maintenance more difficult
-
Client-side validations can be useful, but are generally unreliable
-
combined with other techniques, client-side validation can be a convenient way to provide users with immediate feedback
-
it's a good idea to keep your controllers skinny
-
model-level validations are the most appropriate in most circumstances.
-
Active Record uses the new_record? instance method to determine whether an object is already in the database or not.
-
Creating and saving a new record will send an SQL INSERT operation to the database. Updating an existing record will send an SQL UPDATE operation instead. Validations are typically run before these commands are sent to the database
-
The bang versions (e.g. save!) raise an exception if the record is invalid.
-
save and update return false
-
create just returns the object
-
skip validations, and will save the object to the database regardless of its validity.
-
be used with caution
-
update_all
-
save also has the ability to skip validations if passed validate: false as argument.
-
save(validate: false)
-
valid? triggers your validations and returns true if no errors
-
After Active Record has performed validations, any errors found can be accessed through the errors.messages instance method
-
By definition, an object is valid if this collection is empty after running validations.
-
validations are not run when using new.
-
invalid? is simply the inverse of valid?.
-
To verify whether or not a particular attribute of an object is valid, you can use errors[:attribute]. I
-
only useful after validations have been run
-
Every time a validation fails, an error message is added to the object's errors collection,
-
All of them accept the :on and :message options, which define when the validation should be run and what message should be added to the errors collection if it fails, respectively.
-
validates that a checkbox on the user interface was checked when a form was submitted.
-
agree to your application's terms of service
-
'acceptance' does not need to be recorded anywhere in your database (if you don't have a field for it, the helper will just create a virtual attribute).
-
It defaults to "1" and can be easily changed.
-
use this helper when your model has associations with other models and they also need to be validated
-
valid? will be called upon each one of the associated objects.
-
work with all of the association types
-
Don't use validates_associated on both ends of your associations.
-
-
-
each associated object will contain its own errors collection
-
errors do not bubble up to the calling model
-
when you have two text fields that should receive exactly the same content
-
This validation creates a virtual attribute whose name is the name of the field that has to be confirmed with "_confirmation" appended.
-
To require confirmation, make sure to add a presence check for the confirmation attribute
-
this set can be any enumerable object.
-
The exclusion helper has an option :in that receives the set of values that will not be accepted for the validated attributes.
-
:in option has an alias called :within
-
validates the attributes' values by testing whether they match a given regular expression, which is specified using the :with option.
-
attribute does not match the regular expression by using the :without option.
-
validates that the attributes' values are included in a given set
-
:in option has an alias called :within
-
specify length constraints
-
:minimum
-
:maximum
-
:in (or :within)
-
:is - The attribute length must be equal to the given value.
-
:wrong_length, :too_long, and :too_short options and %{count} as a placeholder for the number corresponding to the length constraint being used.
-
split the value in a different way using the :tokenizer option:
-
-
-
validates that your attributes have only numeric values
-
By default, it will match an optional sign followed by an integral or floating point number.
-
set :only_integer to true.
-
allows a trailing newline character.
-
:greater_than
-
:greater_than_or_equal_to
-
:equal_to
-
:less_than
-
:less_than_or_equal_to
-
:odd - Specifies the value must be an odd number if set to true.
-
:even - Specifies the value must be an even number if set to true.
-
validates that the specified attributes are not empty
-
if the value is either nil or a blank string
-
validate associated records whose presence is required, you must specify the :inverse_of option for the association
-
inverse_of
-
an association is present, you'll need to test whether the associated object itself is present, and not the foreign key used to map the association
-
false.blank? is true
-
validate the presence of a boolean field
-
ensure the value will NOT be nil
-
validates that the specified attributes are absent
-
not either nil or a blank string
-
be sure that an association is absent
-
false.present? is false
-
validate the absence of a boolean field you should use validates :field_name, exclusion: { in: [true, false] }.
-
validates that the attribute's value is unique right before the object gets saved
-
a :scope option that you can use to specify other attributes that are used to limit the uniqueness check
-
a :case_sensitive option that you can use to define whether the uniqueness constraint will be case sensitive or not.
-
There is no default error message for validates_with.
-
To implement the validate method, you must have a record parameter defined, which is the record to be validated.
-
the validator will be initialized only once for the whole application life cycle, and not on each validation run, so be careful about using instance variables inside it.
-
passes the record to a separate class for validation
-
use a plain old Ruby object
-
validates attributes against a block
-
The block receives the record, the attribute's name and the attribute's value. You can do anything you like to check for valid data within the block
-
will let validation pass if the attribute's value is blank?, like nil or an empty string
-
the :message option lets you specify the message that will be added to the errors collection when validation fails
-
skips the validation when the value being validated is nil
-
specify when the validation should happen
-
raise ActiveModel::StrictValidationFailed when the object is invalid
-
You can do that by using the :if and :unless options, which can take a symbol, a string, a Proc or an Array.
-
use the :if option when you want to specify when the validation should happen
-
using eval and needs to contain valid Ruby code.
-
Using a Proc object gives you the ability to write an inline condition instead of a separate method
-
have multiple validations use one condition, it can be easily achieved using with_options.
-
implement a validate method which takes a record as an argument and performs the validation on it
-
validates_with method
-
implement a validate_each method which takes three arguments: record, attribute, and value
-
combine standard validations with your own custom validators.
-
:expiration_date_cannot_be_in_the_past, :discount_cannot_be_greater_than_total_value
-
By default such validations will run every time you call valid?
-
errors[] is used when you want to check the error messages for a specific attribute.
-
Returns an instance of the class ActiveModel::Errors containing all errors.
-
lets you manually add messages that are related to particular attributes
-
using []= setter
-
errors[:base] is an array, you can simply add a string to it and it will be used as an error message.
-
use this method when you want to say that the object is invalid, no matter the values of its attributes.
-
clear all the messages in the errors collection
-
calling errors.clear upon an invalid object won't actually make it valid: the errors collection will now be empty, but the next time you call valid? or any method that tries to save this object to the database, the validations will run again.
-
the total number of error messages for the object.
-
.errors.full_messages.each
-
.field_with_errors
118More
Active Record Migrations - Ruby on Rails Guides - 0 views
-
-
-
-
-
add_column and remove_column
- ...114 more annotations...
-
allowing your schema and changes to be database independent.
-
each migration as being a new 'version' of the database
-
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.
-
A primary key column called id will also be added implicitly, as it's the default primary key for all Active Record models
-
roll this migration back, it will remove the table
-
timestamps macro adds two columns, created_at and updated_at
-
On databases that support transactions with statements that change the schema, migrations are wrapped in a transaction
-
reversible
-
use up and down instead of change
-
Migrations are stored as files in the db/migrate directory, one for each migration class.
-
a UTC timestamp identifying
-
Rails uses this timestamp to determine which migration should be run and in what order
-
"AddXXXToYYY" or "RemoveXXXFromYYY"
-
use a Ruby DSL
-
column type as references
-
part_number:string:index
-
a migration to remove a column
-
"CreateXXX"
-
change_column_null
-
AddUserRefToProducts
-
:references
-
produce join tables if JoinTable is part of the name
-
CreateJoinTable
-
The model and scaffold generators will create migrations appropriate for adding a new model.
-
enclosed by curly braces and follow the field type
-
create_table
-
By default, create_table will create a primary key called id
-
add an index on the new column
-
when using MySQL, the default is ENGINE=InnoDB
-
create_join_table creates an HABTM (has and belongs to many) join table
-
To customize the name of the table, provide a :table_name option:
-
create_join_table also accepts a block
-
change_table, used for changing existing tables
-
remove
-
rename
-
add_column
-
change_column
-
remove_column
-
change_column_default
-
place an SQL fragment in the :options option.
-
limit
-
precision
-
scale
-
polymorphic
-
default
-
index
-
add_foreign_key
-
Active Record only supports single column foreign keys.
-
use the old style of migration using up and down methods instead of the change method.
-
.connection.execute
-
change_table is also reversible, as long as the block does not call change, change_default or remove.
-
remove_column is reversible if you supply the column type as the third argument
-
Complex migrations may require processing that Active Record doesn't know how to reverse
-
reversible
-
Using reversible will ensure that the instructions are executed in the right order too.
-
add_column add_foreign_key add_index add_reference add_timestamps change_column_default (must supply a :from and :to option) change_column_null create_join_table create_table disable_extension drop_join_table drop_table (must supply a block) enable_extension remove_column (must supply a type) remove_foreign_key (must supply a second table) remove_index remove_reference remove_timestamps rename_column rename_index rename_table
-
:column_options option
-
have the option :null set to false by default
-
By default, the name of the join table comes from the union of the first two arguments provided to create_join_table
-
in alphabetical order
-
change_column command is irreversible.
-
-
-
If the column names can not be derived from the table names, you can use the :column and :primary_key options.
-
figure out the column name
-
foreign key for a specific column
-
foreign key by name
-
-
-
Active Record knows how to reverse the migration automatically
-
should use reversible or write the up and down methods instead of using the change method
-
If your migration is irreversible, you should raise ActiveRecord::IrreversibleMigration from your down method.
-
DontUseConstraintForZipcodeValidationMigration
-
rails db:migrate
-
the db:migrate task also invokes the db:schema:dump task, which will update your db/schema.rb file to match the structure of your database.
-
specify a target version
-
all migrations up to and including 20080906120000
-
run the down method on all the migrations down to, but not including, 20080906120000
-
rails db:rollback
-
db:migrate:redo task is a shortcut for doing a rollback and then migrating back up again
-
-
-
STEP parameter
-
db:setup task will create the database, load the schema and initialize it with the seed data
-
db:reset task will drop the database and set it up again. This is functionally equivalent to rails db:drop db:setup.
-
run a specific migration up or down, the db:migrate:up and db:migrate:down
-
the RAILS_ENV environment variable
-
db:migrate VERBOSE=false will suppress all output.
-
If you have already run the migration, then you cannot just edit the migration and run the migration again: Rails thinks it has already run the migration and so will do nothing when you run rails db:migrate.
-
must rollback the migration (for example with bin/rails db:rollback), edit your migration and then run rails db:migrate to run the corrected version.
-
editing existing migrations is not a good idea.
-
should write a new migration that performs the changes you require
-
revert method can be helpful when writing a new migration to undo previous migrations in whole or in part
-
require_relative
-
revert
-
They are not designed to be edited, they just represent the current state of the database.
-
Schema Files for
-
Schema files are also useful if you want a quick look at what attributes an Active Record object has
-
annotate_models gem automatically adds and updates comments at the top of each model summarizing the schema if you desire that functionality.
-
database-independent
-
multiple databases
-
db/schema.rb cannot express database specific items such as triggers, stored procedures or check constraints
-
you can execute custom SQL statements, the schema dumper cannot reconstitute those statements from the database
-
db:structure:dump
-
-
資料庫種類不相依的 schema 付出的代價就是有些特殊的資料庫特性無法描述出來，例如 trigger；如果有在 migration 寫 SQL 的，簡單說 schema dumper 這邊就要設定成 :sql 而不是預設的 :ruby
-
-
set in config/application.rb by the config.active_record.schema_format setting, which may be either :sql or :ruby.
-
check them into source control.
-
db/schema.rb contains the current version number of the database
-
Validations such as validates :foreign_key, uniqueness: true are one way in which models can enforce data integrity
-
The :dependent option on associations allows models to automatically destroy child objects when the parent is destroyed.
-
Migrations can also be used to add or modify data
-
Initial
-
To add initial data after a database is created, Rails has a built-in 'seeds' feature that makes the process quick and easy.
-
db/seeds.rb
-
rails db:seed
36More
shared by 張 旭 on 22 Jan 14
- No Cached
Active Record Basics - Ruby on Rails Guides - 0 views
guides.rubyonrails.org/active_record_basics.html
ruby rails programming development framework model database object
shared by 張 旭 on 22 Jan 14
- No Cached
-
the model - which is the layer of the system responsible for representing business data and logic.
-
Active Record facilitates the creation and use of business objects whose data requires persistent storage to a database
-
Database Table - Plural with underscores separating words
- ...33 more annotations...
-
objects carry both persistent data and behavior which operates on that data
-
Object-Relational Mapping, commonly referred to as its abbreviation ORM, is a technique that connects the rich objects of an application to tables in a relational database management system
-
Represent associations between these models
-
Validate models before they get persisted to the database
-
The idea is that if you configure your applications in the very same way most of the times then this should be the default way.
-
Rails will pluralize your class names to find the respective database table.
-
use the ActiveRecord::Base.table_name= method to specify the table name
-
Model Class - Singular with the first letter of each word capitalized
-
Foreign keys - These fields should be named following the pattern singularized_table_name_id
-
Primary keys - By default, Active Record will use an integer column named id as the table's primary key
-
created_at
-
updated_at
-
(table_name)_count - Used to cache the number of belonging objects on associations.
-
Object Relational Mapping
-
Single Table Inheritance (STI)
-
rake db:rollback
-
ActiveRecord::Base.primary_key=
-
CRUD is an acronym for the four verbs we use to operate on data: Create, Read, Update and Delete.
-
new method will return a new object
-
create will return the object and save it to the database.
-
Using the new method, an object can be instantiated without being saved
-
user.save will commit the record to the database
-
update_all class method
-
an Active Record object can be destroyed which removes it from the database
-
Validation is a very important issue to consider when persisting to database, so the methods create, save and update take it into account when running: they return false when validation fails and they didn't actually perform any operation on database.
-
a bang counterpart
-
Active Record callbacks allow you to attach code to certain events in the life-cycle of your models
-
Rails keeps track of which files have been committed to the database and provides rollback features
-
rake db:migrate
-
class_name.yml
-
Convention over Configuration
-
-
-
-
1More
OS.js - JavaScript Cloud/Web Desktop Platform - 0 views
-
" OS.js is a JavaScript web desktop implementation for your browser with a fully-fledged window manager, Application APIs, GUI toolkits and filesystem abstraction."
1More
OpenTok | WebRTC Platform for Video, Voice and Messaging from TokBox - 0 views
-
"OpenTok is the leading WebRTC platform for embedding live video, voice, and messaging into your websites and mobile apps."
1More
Unique gradient generator - 0 views
-
"This tool helps you to generate beautiful blurry background images that you can use in any project. It doesn't use CSS3 gradients, but a rather unique approach. It takes a stock image, extracts a very small area (sample area) and scales it up to 100%. The browser's image smoothing algorithm takes care of the rest. You can then use the image as an inline, base64 encoded image in any HTML element's background, just click Generate CSS button at the bottom of the app. Select source images from the gallery or use yours, the possibilities are endless."
1More
How to Safely Store Your Users' Passwords in 2016 - Paragon Initiative Enterprises Blog - 0 views
1More
interact.js - JavaScript drag and drop, resizing and gestures with inertia and snapping - 0 views
-
"JavaScript drag and drop, resizing and multi-touch gestures with inertia and snapping for modern browsers (and also IE8+)"
View AllMost Active Members
View AllTop 10 Tags
- 151system
- 133programming
- 102docker
- 101rails
- 89development
- 83devops
- 81kubernetes
- 80javascript
- 77database
- 71ruby
- 68linux
- 64web
- 61server
- 58networking
- 52security
- 49python
- 42mysql
- 42php
- 40framework
- 35performance