I'm a developer

creact

by biglovisa

biglovisa /creact

crud in Rails and React | Tutorial

128 Stars 43 Forks Last release: Not found 100 Commits 0 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Creact

Crud + React

In this tutorial we are going to clone down a repo with a Rails API and build out a React front end using the react-rails gem. We won't cover the Rails API in detail and it is assumed that you are familiar with the general structure of a Rails project and JavaScript syntax.

Sections


0. Up and running

In your terminal, clone the project:

$ git clone [email protected]:applegrain/creact-starter.git; cd creact-starter
$ bundle install
$ rake db:setup

If you were instead to run 

$ rake db:{create,migrate,seed}
you might have trouble and get something like 
NoMethodError for details=
. This is because when we manually run the 
migrate
command, Rails doesn't know that it needs to reset column information on what was just migrated to account for potentially new columns, so it hiccups trying to call methods on those columns. Conversely, the 
setup
command includes a step for resetting columns, so we're in the clear to then call methods.

run tests with:

$ bundle exec rspec

and start the server with:

$ bundle exec rails s


1. What's already here?

If you start the server and go to 

http://localhost:3000
you'll see an 
h1
tag and many skills - each with a name, details and a level set as enum. The seed data doesn't really reflect the fact that it is a skill. Feel free to change the Faker options in 
db/seeds.rb
.

In 

config/routes.rb
there is already a root path set up. This will be the only route we are going to use. We also have a 
app/controllers/site_controller.rb
with an index action that passes the instance variable 
@skills
to the view. In the view, 
app/views/site/index.html.erb
, we are iterating over 
@skills
to render all the skills on the DOM. Later we are going to delete the instance variable in the action and have an almost empty view.

In 

config/routes.rb
there is also routes for 
Api::V1::Skills
. The json API is already built out with the necessary actions. In 
app/controllers/api/v1/skills_controller.rb
we are serving json from four endpoints.

Further resources on building a json API


2. Adding React to your Rails project

React.js is a "JavaScript library for building user interfaces". It's a tiny framework used to build your view layer. React can be used in combination with almost any back end, and can be combined with other front end frameworks as well. React, can be sprinkled in anywhere in your Rails application. React could be used for a search bar, be part of the nav bar or be used for the whole page.

React is a JavaScript library but fortunately we can use the react-rails gem that enables us to use React and JSX in our Rails application. You'll get more familiar with JSX a bit further down but it's basically the equivalent to erb. It's how we mix JavaScript with HTML - the same way we can mix Ruby with HTML when we use erb.


Add 

gem 'react-rails'
to your Gemfile. 


$ bundle
$ rails g react:install

The last command generated a file, created a directory and inserted three lines to our code.


$ rails g react:install
    create  app/assets/javascripts/components
    create  app/assets/javascripts/components/.gitkeep
    insert  app/assets/javascripts/application.js
    insert  app/assets/javascripts/application.js
    insert  app/assets/javascripts/application.js
    create  app/assets/javascripts/components.js


If you open up 

app/assets/javascripts/application.js
you'll see the three lines React inserted. 


//= require react
//= require react_ujs
//= require components


Just like jQuery, we require 

react
, 
react_ujs
and 
components
to the asset pipeline. In 
app/assets/javascripts/components.js
we require the directory 
components
. It's in this directory where all our React components will live. Think of a component as a type of class, it represents a "unit" of code. We build many small components that we combine to build bigger features.


3. Component Hierarchy

The notation for rendering React components is: .

Components have parent-child relationships, if component "Cat" renders component "Kitten", "Cat" is the parent of "Kitten". As an example, let's build the component hierarchy for a site with a header, a side bar and tweets:

The main component,

, will render the
and 
 component. The 
Header
 and the 
Body
 components exist independently of each other but they need to know about similar data, such as the current user or which link in the header was clicked last. We can store that information and keep track of the current state of our application in 
Main
 and pass it down to 
Header
 and 
Body
. By storing the data in one place we are also only updating the data in one place - we have a so-called "Single Source of Truth", one place where data is stored and updated.


In 
, we render 
 and 
. 
 and 
 don't really depend on the same data but rendering both of them in the 
Body
 makes sense since they might share styling attributes. Finally, 
 renders an entire collection of 
. Each individual tweet is a single 
Tweet
 component to keep it DRY: "Don't Repeat Yourself".





          Main
        /      \
       /        \
    Header       Body
                /     \
             Ads     Tweets
                          \______
                              |   Tweet
                              |       _\_
                              |      /    \
                              |  Body   TweetOptionsBars
                              |
                              |___
                              |   Tweet
                              |       _\_
                              |      /    \
                              |  Body   TweetOptionsBars
                              |
                              etc




additional resources on component hierarchy:
- Thinking in React
- Video tutorial that walks through the code used in above article



4. Our first React component






Now we need to connect our Rails views to our (yet non-existent) React code. First, add a file to the components directory. This will be our main file.






$ touch app/assets/javascripts/components/_main.js.jsx







The 
.js.jsx
 extension is similar to 
html.erb
. In Rails views, we write erb that gets compiled down to HTML. With 
js.jsx
 files, we write JSX that gets compiled to JavaScript.


Then we establish a connection between the Rails view and the main component. To render 
_main.js.jsx
 in our root we need to add the view helper we get from the react-rails gem. It puts a div on the page with the requested component class. Go ahead and delete the old code in the view. Since we use React as our view layer, our Rails views are next to empty (as they should be).






Since the Rails asset pipeline will take all of our JavaScript and mash it together, the names of the JavaScript files don't really matter. Below, React will look for a component that's named 
Main
.


app/views/site/index.html.erb
```



<%= react_component 'Main' %>




And let's add our first React component - head to the browser and make sure it works.




app/assets/javascripts/components/_main.js.jsx



var Main = React.createClass({
  render() {
    return (
      

        
Hello, Creact!

      

    )
  }
});

If you're receving an error about Rails not recognizing your react_components, be sure to restart your server.





5. Hello, Creact!




We did it! We have copy-pasted our first component and our Rails view is empty. Let's take a closer look at Main.


We have built a component and given it a name. It has only one function, render(). When a React component is mounted on the DOM, its render() method will execute and also trigger it's children's render() methods. The code that's in the return statement is the JSX that will render on the page. Right now our HTML looks like regular HTML, but soon we will add in some JavaScript so it becomes more dynamic. Each React component can only return one element, so all JSX elements in the return statement need to be in one wrapper div.





Bad - returning sibling HTML elements that aren't wrapped by a shared parent div.




return (
  

    
Hello, Creact!

  

  

    
All of the contents

  

)





Better - we have multiple sibling HTML elements which share a parent div.




return (
  

    

      
Hello, Creact!

    

    

      
All of the contents

    

  

)
```






Let's build out the component hierarchy. We are going to implement basic CRUD functionality; create, read, update, delete. Our 
Main
 component could render a 
Header
 and a 
Body
. In the 
Body
, we need to be able to view all skills, create a new skill, edit a skill and delete a skill. So, 
Body
 could render 
 and 
. 
NewSkill
 is a form to create new skills and 
AllSkills
 renders a collection of individual 
Skill
 components - each 
Skill
 component has it's own delete and edit button.





         Main
       /      \
  Header        Body
              /     \
        NewSkill    AllSkills
                        \
                        Skills * n








Let's remove our current 
h1
 and add 
 in it's place.






app/assets/javascripts/components/_main.js.jsx

var Main = React.createClass({
  render() {
    return (
      

        

      

    )
  }
});








We are rendering the 
Header
 component (still non-existent) in the 
Main
 component, which makes 
Header
 the child of 
Main
.





$ touch app/assets/javascripts/components/_header.js.jsx







Our code for the 
Header
 component will look very similar to what we have in 
Main
. For now, put an 
h1
 in the return statement with whatever text you want. Hop over to your browser to make sure the 
h1
 renders as it should. If not, take a look at the code we first had in 
Main
 and compare the syntax. Let's leave the 
Header
 for now and move on to building out the body.






6. Rendering all skills






Now let's render all skills on the page. First, we need to add a 
Body
 component in which our 
NewSkill
 and 
AllSkills
 components will be rendered.

$ touch app/assets/javascripts/components/_body.js.jsx
$ touch app/assets/javascripts/components/_all_skills.js.jsx
$ touch app/assets/javascripts/components/_new_skill.js.jsx



Go ahead and add the code from 
Header
 in the 
Body
, 
AllSkills
 and 
NewSkill
 components. 
Body
 should render 
AllSkills
. Put an arbitrary 
h1
 in 
AllSkills
 so we can get some feedback on the page. At this point, two 
h1
's should be rendered on the page. If they don't, open up the dev tools (option + cmd + i) and see if you have any errors in the console. If they aren't useful, look over the syntax carefully and make sure it looks like what we have in 
Main
.


Our next step is to fetch all skills from the server. We will use Ajax to ping the index action of our Rails API to get all the skills from the database. It's important that our Ajax call is only executed once. It's expensive to make Ajax calls and depending on the scale of your applications, it can cause performance issues. If we were using jQuery, we would implement this in a 
$(document).ready()
 function.


React components have some built in methods available that execute during different points during a component's lifecycle. Some examples include functions that execute before/after a component mounts on the DOM and before/after it dismounts. In this case, we want a method that renders once when the component is mounted on the DOM. We are going to use 
componentDidMount()
 which is called right after the component is mounted. For more details about methods that are available to components and when to use them, check out the docs.


Let's add a 
componentDidMount()
 function and just 
console.log()
 something so we now it's being called.






app/assets/javascripts/components/allskills.js.jsx
```
var AllSkills = React.createClass({
  componentDidMount() {
    console.log('Hello');
  },



render() {
    return (
      

        
Hello from All Skills!

      

    )
  }
});





Why is there a comma at the end of our function? Take a closer look at the syntax. When we write var AllSkills = React.createClass( /* Code here */ ) we give it an object containing all the code for the component. Since elements in objects are comma separated, we put a comma at the end of our functions.


Did you see the output from the console.log() in the browser console? Cool! Let's see if we can fetch all skills.




$.getJSON('/api/v1/skills.json', (response) => { console.table(response) });
```



Make sure to look in the browser console to make sure everything looks good.



Right now we are just logging the result to make sure we get the objects we want. Really, what we want to do is to store it on the component so we can use it more easily throughout our application. Data that will change is stored as 
state
 on the component. In React, state is mutable, so data that will change throughout the program should be stored as state. 
getInitialState
 is another method we get from React and it's used to  specify the initial values for all the states in the component. Let's create a state called 
skills
 and set it equal to an empty array.






app/assets/javascripts/components/allskills.js.jsx
```
var AllSkills = React.createClass({
  getInitialState() {
    return { skills: [] }
  },



// rest of the component






Now, when we get the response back from the server, we want to update skills and set it to the value of the skills we got from the server. We want to store it as state because when we add new skills, we want to be able to render them on the page without having to ping the index action of our API again. By using another of React's built in methods, this isn't bad at all.







$.getJSON('/api/v1/skills.json', (response) => { this.setState({ skills: response }) });
```







To be sure that we actually updated the state, let's log the state (
console.log(this.state)
) in the 
render()
 method. Make sure to put it outside of the return statement! You should see something like the following in your browser console.


this.state.skills
 is how we would access the skills array.





> Object {skills: Array[0]}
> Object {skills: Array[50]}







We might eventually want to create a 
Skill
 component for each object in the skills array. For now, let's just map over the objects in the array and create DOM nodes out of them. Since JSX is just HTML + JS, we can build HTML elements and insert JavaScript wherever we need it, similar to how we can insert Ruby in HTML elements using erb.






app/assets/javascripts/components/allskills.js.jsx
```
// componentDidMount() and getInitialState()



render() {
    var skills = this.state.skills.map((skill) => {
      return (
        

          
{skill.name}

          
Level: {skill.level}

          
{skill.details}

        

      )
    });

return(
  

    {skills}
  

)



}
```







The return value from the 
this.state.skills.map...
 will be an array of HTML divs, each with an 
h3
 and two 
p
 tags (if you don't believe me, log the return value and look). As you can see, inserted JavaScript needs to be enclosed in curly braces - the erb equivalent to this would be 
. In the return statement we have replaced the 
h1
 tag with the skills array we built above. In the return statement we write JSX and our skills array is JavaScript, so in order for it to be evaluated it needs to be wrapped in curly braces. Head over to the browser and make sure it all works ok!


You should see an error like this in the browser console:






Each child in an array or iterator should have a unique "key" prop. Check the render method of `AllSkills`. See https://fb.me/react-warning-keys for more information.







A key prop?



When we are rendering multiple similar HTML elements - in our case, 50 of the same type - we need to supply each with a unique key. React uses a diffing algorithm to figure out which parts of your application has changed and needs to be re-rendered. This is partially what makes React so fast and snappy in the browser. It uses the keys to identify the DOM nodes and if we have several on the same kind, the diffing algorithm doesn't work as it should. For more details on this topic, check out the docs.



Let's help React out and add a key prop.






var skills = this.state.skills.map((skill) => {
  return (
    

      
{skill.name}

      
Level: {skill.level}

      
{skill.details}

    

  )
});








We can use each skill's id as a unique key. Refresh, and voila - no more errors.







7. Add a new skill






Remember the 
NewSkill
 component?


app/assets/javascripts/components/newskill.js.jsx
```
var NewSkill = React.createClass({
  render() {
    return (
      

        
new skill

      

    )
  }
});





What do we need to create a new skill? We need a form where the user can enter a name and details and a submit button which will take the input from the form and send it over to the API and add the skill to the database. Let's start with the form. We are just going to use regular HTML to get the form and the submit button on the page.


When we are submitting this new skill, we need to grab the text contents of the two input fields, the name and the details, and store it in our database. In the earlier days of React, we could have used refs, but nowadays it's more common to use an onChange handler and store the text on state. As you can see below, in the onChange handlers we are executing an anonymous function which takes an event object as its argument, and then sets the state of name or details to the current text value.





app/assets/javascripts/components/_new_skill.js.jsx



getInitialState() {
  return { name: '', details: '' }
},



return (
  

     this.setState({ name: e.target.value }) } placeholder='Enter name of skill' />
     this.setState({ details: e.target.value }) } placeholder='Details' />
    Submit
  

)
```






Cool cool cool - but what happens when the user has entered a new skill and hits submit? Nothing. Let's add an event listener.






Submit







onClick
 is a React event listener, take a look at the docs to learn more about React events. We give the event listener some JavaScript code to evaluate whenever we click the button. Here, we are telling it to go execute the 
handleClick
 function - which we haven't written yet.





// var NewSkill = ...


handleClick() {
  console.log('in handle click!')
},


// render()....








Check in the browser if it works and... great! Now, we need to fetch the form values and send it over to the server to create a new skill. Let's log the form values to be sure we have access to them.






var name    = this.state.name;
var details = this.state.details;
console.log(name, details);







Let's send the form values over to the server so we can create a new skill.






handleClick() {
  var name    = this.state.name;
  var details = this.state.details;


  $.ajax({
    url: '/api/v1/skills',
    type: 'POST',
    data: { skill: { name: name, details: details } },
    success: (response) => {
      console.log('it worked!', response);
    }
  });
},








We are making a POST request to '/api/v1/skills' and if it's successful we log the response. Did it work? Create a new skill in the browser and check the browser console. Refresh the page to make sure your newly created skill is rendered on the page.



But we don't want to refresh the page to see our new skills. We can do better.



We store all the skills we get from the server as state in 
AllSkills
. When we add a new skill, we could add it to the skills array so it will get rendered immediately with the other skills. 
AllSkills
 needs to have access to the skills array and 
NewSkill
 wants to update that array. Both children of 
Body
 need access to the skills array so we should store it as state in 
Body
 and give both children access to it.


Let's move some code around. Move 
getInitialState()
 and 
componentDidMount()
 from 
AllSkills
 to 
Body
. Now, we fetch the skills when 
Body
 is mounted on the DOM and we store them as state on the 
Body
 component.


How does 
AllSkills
 get access to all the skills?


Parents can send variables down to their children as 
props
. 
Props
 are immutable in the child. Let's send the skills array from the 
Body
 component to the 
AllSkills
 component as props.






app/assets/javascripts/components/_body.js.jsx








We have one more change to do before the skills will render on the DOM. In 
AllSkills
 we are iterating over 
this.state.skills
 to create DOM elements but we no longer have that state stored on the component. 
AllSkills
 receives the skills as props from the parent, so instead of 
this.state.skills
 we need to ask for 
this.props.skills
.






app/assets/javascripts/components/allskills.js.jsx
```
var skills = this.props.skills.map((skill) => {
  return (
    

      
{skill.name}

      
Level: {skill.level}

      
{skill.details}

    

  )
});





Like we can pass down values from parents to children, we can also pass function references that can be executed in the child.


Let's starts from the Body. We want to build a function that's called handleSubmit() that will add the new skill to the skills array.





app/assets/javascripts/components/_body.js.jsx



// getInitialState() and componentDidMount()



handleSubmit(skill) {
  console.log(skill);
},



// renders the AllSkills and NewSkill component






Then, we want to send a reference to this function down to the NewSkill component.








```







In the 
NewSkill
 component, we can call this function by adding parenthesis, just like a regular JavaScript function. In the 
success
 function, execute the 
handleSubmit
 function and give it the name and details as an object as an argument.






app/assets/javascripts/components/newskill.js.jsx

$.ajax({
  url: '/api/v1/skills',
  type: 'POST',
  data: { skill: { name: name, details: details } },
  success: (skill) => {
    this.props.handleSubmit(skill);
  }
});








Check your browser console to see if you get any output from 
handleSubmit
 in the 
Body
 component.


Almost there!



Now we need to add it to 
this.state.skills
. We can use 
concat()
 to add the skill to the old state and then set the state with the new state.






app/assets/javascripts/components/_body.js.jsx

handleSubmit(skill) {
  var newState = this.state.skills.concat(skill);
  this.setState({ skills: newState })
},








That's it! We have successfully added a new skill that is rendered on the DOM immediately.



Here is the code for 
Body
, 
AllSkills
 and 
NewSkill
 in case you want to check your code.






app/assets/javascripts/components/_body.js.jsx
```
var Body = React.createClass({
  getInitialState() {
    return { skills: [] }
  },



componentDidMount() {
    $.getJSON('/api/v1/skills.json', (response) => { this.setState({ skills: response }) });
  },



handleSubmit(skill) {
    var newState = this.state.skills.concat(skill);
    this.setState({ skills: newState })
  },



render() {
    return (
      

        
        
      

    )
  }
});





app/assets/javascripts/components/_all_skills.js.jsx



var AllSkills = React.createClass({
  render() {
    var skills = this.props.skills.map((skill) => {
      return (
        

          
{skill.name}

          
Level: {skill.level}

          
{skill.details}

        

      )
    });

return (
  

    {skills}
  

)



}
});






app/assets/javascripts/components/_new_skill.js.jsx



var NewSkill = React.createClass({
  handleClick() {
    var name    = this.state.name;
    var details = this.state.details;


$.ajax({
  url: '/api/v1/skills',
  type: 'POST',
  data: { skill: { name: name, details: details } },
  success: (skill) => {
    this.props.handleSubmit(skill);
  }
});



},



render() {
    return (
      

         this.setState({ name: e.target.value }) } placeholder='Enter name of skill' />
         this.setState({ details: e.target.value }) } placeholder='Details' />
        Submit
      

    )
  }
});





8. Delete a skill




Ok, we can render skills and add new ones. Let's implement deleting skills so we can get rid of all the test skills we have added.


What do we need to do?


    

  1. Add a delete button to each skill
    2. 

  2. Create a click event for the delete button that will travel up to Body
    3. 

  3. Remove the the skill from the skills array
    4. 

  4. Update the state in Body with the new skills array
    5. 

  5. Make an Ajax call to our server to remove it from the database
    6. 



Let's start with adding a delete button to each skill with an on click listener that takes us to the function handleDelete in the same component.





app/assets/javascripts/components/_all_skills.js.jsx



var AllSkills = React.createClass({
  handleDelete() {
    console.log('in delete skill');
  },



render() {
    var skills = this.props.skills.map((skill) => {
      return (
        

          
{skill.name}

          
Level: {skill.level}

          
{skill.details}

          Delete
        

      )
    });

return (
  

    {skills}
  

)



}
});
```




Does it log to the browser console? Cool, we are good to go. Earlier I said that we were going to add a 
Skill
 component for each skill, but we aren't feeling any obvious pains from this setup, so let's keep it like it is.


The component needs to communicate with the parent and tell it to delete the idea that was clicked. Like we passed down a function 
ref
erence to 
NewSkill
, we are going to pass down a function reference that the child can execute when we click the 
delete
 button.






app/assets/javascripts/components/_body.js.jsx
```
// getInitialState() and componentDidMount()



handleDelete() {
  console.log('in handle delete');
},



// render 




```







Great! Now, we need to execute the function in the child when we hit the 
handleDelete()
.






app/assets/javascripts/components/allskills.js.jsx
```
var AllSkills = React.createClass({
  handleDelete() {
    this.props.handleDelete();
  },



// render() ...






We have one pretty obvious problem to solve before we continue. How does the program know which skill it is that we want to delete? In the Body component we need to use some data that identifies the skill we want to remove so we can filter it out from the skills array. How about an id?


If we use the skill id and pass it as an argument to this.props.handleDelete() we can easily filter the correct skill out by filtering out the skill with a matching id.


Let's use our friend bind() - the first argument in bind() is the value to be passed as the this value when the function is executed and consecutive arguments will be passed to the bound function as arguments.





app/assets/javascripts/components/_all_skills.js.jsx



handleDelete(id) {
  this.props.handleDelete(id);
},



// iterate over the skills and create HTML elements



Delete



// render() etc






Now, in handleDelete() in the Body component we need to use the id passed up from the AllSkills component and remove the skill from the database using an Ajax call.





app/assets/javascripts/components/_body.js.jsx



handleDelete(id) {
  $.ajax({
    url: 
/api/v1/skills/${id}
,
    type: 'DELETE',
    success(response) {
      console.log('successfully removed skill', response)
    }
  });
},
```






Click 
delete
 and check in the console if it worked - you are awesome!


But... unless we refresh the page, the skill is still there. We aren't communicating to our view that the skill should be deleted.



Let's add a callback in the 
success()
 function that removes the skill from the DOM.






app/assets/javascripts/components/_body.js.jsx
``
handleDelete(id) {
  $.ajax({
    url:
/api/v1/skills/${id}`,
    type: 'DELETE',
    success: () => {
      this.removeSkillFromDOM(id);
    }
  });
},


removeSkillFromDOM(id) {
  var newSkills = this.state.skills.filter((skill) => {
    return skill.id != id;
  });



this.setState({ skills: newSkills });
},
```







Hop over to the browser and remove some skills... this is fantastic.







9. Edit a skill



The last and final crud functionality. We are rendering all skills on the page, we are creating new ones, we are deleting them and now we just need to be able to edit them.



This is what we need to accomplish:



    

  1. Add an 
    Edit
     button
    2. 

  2. Add a click listener for the 
    Edit
     button
    3. 

  3. On click 
    Edit
    , transform the text fields to input fields (alternatively render a new form below)
    4. 

  4. When the user clicks the 
    Submit
     button, grab the values from the input fields
    5. 

  5. Send the updated values over to our Rails API to update the skill
    6. 

  6. Update the skill and replace the old values with the new values
    7. 




Let's start with 
1
 and 
2
. Add an 
Edit
 button and add a click listener for it which takes us to a 
handleEdit
 function in the same component.






app/assets/javascripts/components/allskills.js.jsx
```
// handleDelete()



handleEdit() {
  console.log('you are in edit!');
},



// render() and rest of the skill template



Edit
```







Do you get feedback in your browser console when we click 
Edit
? Cool.


What needs to happen in 
handleEdit()
? For the specific skill that the user asked to edit, add an edit form and var the user edit the values and then submit. If we were using jQuery, we could have just used jQuery's 
$.append()
 function. However, as this StackOverflow succinctly puts it, it's not a React way. We should render components conditionally based on our state and props.


So if each skill needs to know whether or not its 
Edit
 button has been clicked (information which we should store as state), this seems like a good time to refactor out our current skill template in 
AllSkills
 to its own component.





$ touch app/assets/javascripts/components/_skill.js.jsx







We need to update 
AllSkills
 and create 
Skill
 components when we iterate over the 
this.props.skills
. Notice that we need to send the skill, and references to 
handleDelete()
 and 
handleEdit()
 as props to 
Skill
. This way we can access these values in 
Skill
 using the 
this.props.*
 notation.






app/assets/javascripts/components/allskills.js.jsx
```
render () {
  var skills = this.props.skills.map((skill) => {
    return (
      

        
      


    )
  });


// return () the skills array
}
```







In 
Skill
 we just return the entire template we removed from 
AllSkills
. Notice how we changed the JSX to comply with our new setup.






app/assets/javascripts/components/_skill.js.jsx
```
var Skill = React.createClass({
  render() {
    return (
      

        
{this.props.skill.name}

        
Level: {this.props.skill.level}

        
{this.props.skill.details}


    
      Delete
    


<button onclick="{this.props.handleEdit}">Edit</button>


  



)


}
});
```







Just to double check that we have wired things up correctly, go to the browser and make sure you can still delete skills and that something logs to the console when you click 
Edit
.


Now, when we click 
Edit
, we want to set a state that will tell us that we are editing the skill. Change the click listener for the 
Edit
 button so we land in a handler function in the current component,





Edit







and add that function in the 
Skill
 component.





handleEdit() {
  // something should happen here
},








Now what? Add an initial state to the 
Skill
 component that defaults to 
false
. In 
handleEdit()
 we need to set this state to true.






app/assets/javascripts/components/_skill.js.jsx
```
var Skill = React.createClass({
  getInitialState() {
    return { editable: false }
  },



handleEdit() {
    this.setState({ editable: true })
  },



// render() etc..
```







And now what? We need to render the component conditionally based on our state. If 
this.state.editable
 is false, we want to render 
h3
 tag with the name and the 
p
 tag with the details as normal. If not, we want to render an input field for the name and a textarea for the details. Sounds like we need ternary operator.






app/assets/javascripts/components/_skill.js.jsx
```
// getInitialState() and handleEdit()...



render() {
  var name = this.state.editable ? 
                                 : 
{this.props.skill.name}



var details = this.state.editable ? 
                                    : 
{this.props.skill.details}

  return (
    

      {name}

  
Level: {this.props.skill.level}

  {details}

  
    Delete
  


  Edit






)
}
});
```







In the render function we are using a ternary to decide how we should render name/details. It doesn't matter what data we give our component, based on its state, props and the constraints we set up, we always know what the component will render. We want dumb child components that just render conditionally based on the props they receive and their current state. Head over to the browser and check it out!



Let's transform the 
Edit
 button to a 
Submit
 button when we click 
Edit
. We can use the 
editable
 state and a ternary directly in the JSX to change that.






app/assets/javascripts/components/_skill.js.jsx

{this.state.editable ? 'Submit' : 'Edit' }








Awesome.



We can make a small change to how we update the state in 
handleEdit()
 to make it toggle between true/false.





handleEdit() {
  this.setState({ editable: !this.state.editable })
},







But now, when we click 
Submit
, we need to fetch the updated values and send them over to the server to update the given skill. We can do this using the same strategy we deployed in 
_new_skill.js.jsx
. Let's add the 
onChange
 callback to the input field and the textarea in 
Skill
 (forgot to carry those over when we extracted the skill to its own component).





getInitialState() {
  return { name: '', details: '' }
},


....


var name = this.state.editable ?  this.setState({ name: e.target.value }) }
                                        defaultValue={this.props.skill.name} />
                               : 
{this.props.skill.name}


var details = this.state.editable ?  this.setState({ details: e.target.value }) }
                                              defaultValue={this.props.skill.details}>
                                    
                                  : 
{this.props.skill.details}








There are no strict rules on how you choose to format ternaries. The most important thing is to make it readable for future you and other developers.



Let's add some code to 
handleEdit()
.





if (this.state.editable) {
  var name    = this.state.name;
  var details = this.state.details;
  console.log('in handleEdit', this.state.editable, name, details);
  this.onUpdate();
}


this.setState({ editable: !this.state.editable })







What are we trying to find out here? When we hit this function and 
this.state.editable
 is true, meaning if we are currently editing the text, we want to grab the name and the details and log them to the browser console. Then, we simply toggle the state to alternate between true/false. Try it out in the browser and make sure it's behaving as expected.


Cool. Let's walk up the chain, from 
Skill
 to 
AllSkills
 to 
Body
 and update the specific skill in the 
Body
 component. Why update the skill in the 
Body
 component and not  right away in the 
Skill
 component? Because we store all skills as state in the 
Body
 component and data should be updated in one place.


Fetch the values, compose a skill object and trigger the chain by executing the 
handleUpdate()
 function reference passed down by the parent.






app/assets/javascripts/components/_skill.js.jsx
```
onUpdate() {
  if (this.state.editable) {
    var name    = this.state.name;
    var details = this.state.details;
    var skill = { name: name, details: details }


this.props.handleUpdate(skill);



}
  this.setState({ editable: !this.state.editable })
},
```







This component is just passing it up to its parent.







app/assets/javascripts/components/allskills.js.jsx
```
onUpdate(skill) {
  this.props.handleUpdate(skill);
},



render() {
  var skills = this.props.skills.map((skill) => {
    return (
      

        
      


    )
  });
```






This is the end of the chain and where we use the 
skill
 object passed up to update the state, 
this.state.skills
.






app/assets/javascripts/components/_body.js.jsx
```
handleUpdate(skill) {
  console.log(skill, 'in handleUpdate');
},



render() {
  return (
    

      
      
    

  )
}
```






Since 
this.state.skills
 is an array of objects it makes most sense to just swap out entire objects instead of opening one up and updating single properties on that object. Let's update the object we pass up from 
Skill
 to look more like the objects we store as state in 
Body
.





var id      = this.props.skill.id;
var name    = this.state.name;
var details = this.state.details;
var level   = this.props.skill.level;


var skill = {id: id, name: name, details: details, level: level }







In 
handleUpdate()
 in the 
Body
 component we need to swap out the old object with the new one - and make an Ajax call to update the database.





handleUpdate(skill) {
  $.ajax({
    url: `/api/v1/skills/${skill.id}`,
    type: 'PUT',
    data: { skill: skill },
    success: () => {
      console.log('you did it');
      this.updateSkills(skill);
      // callback to swap objects
    }
  });
},







And now let's write the callback that will swap out the objects.






handleUpdate(skill) {
    // ajax stuffs
    success: () => {
      this.updateSkills(skill)
    }
  });
},


updateSkills(skill) {
  var skills = this.state.skills.filter((s) => { return s.id != skill.id });
  skills.push(skill);


  this.setState({ skills: skills });
},







First we filter out the skill that matches 
skill.id
, then we are pushing the updated skill onto the filtered skills array and then we are updating the state with the correct values.






10. Updating the level of a skill






Last thing we will do before we see if there are any opportunities to refactor our code is updating the level of a skill. Either we could have three buttons corresponding to each of the levels (bad, half-bad and fantastic), or, we could have an up arrow and a down arrow and when the user clicks either it levels up and down respectively.



It seems like implementing the arrows will take slightly more work, so let's do that.



First, we need our arrow buttons - and we'll be adding our first css!






$ touch app/assets/stylesheets/skills.scss








app/assets/stylesheets/application.scss

@import "skills";








app/assets/stylesheets/skills.scss
```
.skill-level {
  display: inline-flex;
}



.skill-level button {
  background-color: pink;
  border: 1px solid deeppink;
}
```







Wrap the 
level
 with the arrow buttons.






app/assets/components/javascripts/_skill.js.jsx
```


  
    
  

Level: {this.props.skill.level}





    
  




```






Let's write down a todo-list for this feature.



    

  1. Add click events to the arrows - bind an argument to the function so we know which button was clicked
    2. 

  2. In the click handler, check if it's possible to decrease/increase the level (is it already the lowest/highest value?)
    3. 

  3. Depending on #2, send a request to the server to update the status
    4. 




For #3 we can use the same chain we used for editing the name and the details (
this.props.handleUpdate()
).


Let's add a click listener for both arrow buttons and bind arguments to them.







app/assets/components/javascripts/_skill.js.jsx
```


  
    
  

Level: {this.props.skill.level}





    
  









Now we need logic in handleLevelChange() to decide whether or not to update the level when we click either button.





app/assets/components/javascripts/_skill.js.jsx



handleLevelChange(action) {
  var levels  = ['bad', 'halfbad', 'fantastic'];
  var name    = this.props.skill.name;
  var details = this.props.skill.details;
  var level   = this.props.skill.level;
  var index   = levels.indexOf(level);



if (action === 'up' && index < 2) {
    var newLevel = levels[index + 1];
    this.props.handleUpdate({id: this.props.skill.id, name: name, details: details, level: newLevel})
  } else if (action === 'down' && index > 0) {
    var newLevel = levels[index - 1];
    this.props.handleUpdate({id: this.props.skill.id, name: name, details: details, level: newLevel})
  }
},






That code is working. It's not pretty, but it's working.


I'm going to keep it like this and deal with it first thing in next section - time to refactor!





11. Refactor




To refactor the code above, it's a good start to try to state what is happening in the function.


'If the level can be changed, send the updated object up the chain to be updated'.


That gave me this:





app/assets/components/javascripts/_skill.js.jsx



handleLevelChange(action) {
  if (this.levelCanBeChanged(action)) {
    var skill = this.updatedSkill()
    this.props.handleUpdate(skill);
  }
},






this.levelCanBeChanged(action) will return either true or false. We send it the action, either 'up' or 'down', and checks the given limit meets a condition.


app/assets/components/javascripts/_skill.js.jsx



handleLevelChange(action) {
  var levels  = ['bad', 'halfbad', 'fantastic'];
  var level   = levels.indexOf(this.props.skill.level);



if (this.levelCanBeChanged(action, level)) {
    var skill = this.updatedSkill()
    this.props.handleUpdate(skill);
  }
},



levelCanBeChanged(action, limit) {
  return action === 'up' && limit < 2 ||  action === 'down' && limit > 0;
},
```







Next up is 
updatedSkill()
. We return an object with an updated level that is set by checking the action and moving either up or down in an array.






app/assets/components/javascripts/_skill.js.jsx
```
updatedSkill(action, index) {
  var id       = this.props.skill.id;
  var name     = this.props.skill.name;
  var details  = this.props.skill.details;



var levels   = ['bad', 'halfbad', 'fantastic'];
  var change   = action === 'up' ? 1 : - 1;
  var newLevel = action ? levels[index + change] : this.props.skill.level;



return {id: id, name: name, details: details, level: newLevel}
},
```







We can also refactor out the part where we set the new level to a function.







app/assets/components/javascripts/_skill.js.jsx
```
getNewLevel(action, index) {
  var levels   = ['bad', 'halfbad', 'fantastic'];
  var change   = action === 'up' ? 1 : - 1;



return action ? levels[index + change] : this.props.skill.level;
},
```







This looks better, but there is more to do in this component. 
onUpdate()
 can be made better. Let's make it a bit more readable.






app/assets/components/javascripts/_skill.js.jsx
```
onUpdate() {
  if (this.state.editable) {
    var skill   = { id: this.props.skill.id,
                    name: this.state.name,
                    details: this.state.details,
                    level: this.props.skill.level }


this.props.handleUpdate(skill);



}



this.setState({ editable: !this.state.editable })
},
```







The handler function for the level change, 
onLevelChange
, can be renamed to 
onUpdateLevel
 to better match the naming pattern we have for the editing handler function. To make the following code working below I had to update the implemenation of 
this.props.handleUpdate
, 
handleUpdate()
 in the 
Body
 component. In this function we are now only passing up the attributes we need to update (we need the id for the Ajax call). We can therefore also drop the 
level
 attribute in the skill object in 
onUpdate()
.






app/assets/components/javascripts/_skill.js.jsx
```
onUpdateLevel(action) {
  if (this.canChangeLevel(action)) {
    var level = this.getNewLevel(action)
    var skill = {id: this.props.skill.id, level: level }


this.props.handleUpdate(skill);



}
},
```







Since we are no longer passing up a full skill object we can no longer use it to update the skill in 
updateSkills()
. Instead, we need our API to pass the updated object back so we can keep replacing the old skill with the new skill in 
updateSkills
. Otherwise we would have to update only the attributes that were present in the skill object which feels... a bit strange. Also, it's way safer to use the updated object from our API and if we can, we wouldn't we?






app/assets/javascripts/components/_body.js.jsx
``
handleUpdate(skill) {
  $.ajax({
    url:
/api/v1/skills/${skill.id}`,
    type: 'PUT',
    data: { skill: skill },
    success: (skill) => {
      this.updateSkills(skill)
    }
  });
},






app/skills/controllers/api/v1/skills_controller.rb



def update
  skill = Skill.find(params["id"])
  skill.updateattributes(skillparams)
  respond_with skill, json: skill
end
```







12. Filter Skills by Level






Our next step is to filter skills based on the level. Our goal is to create a select input that has an option for each level. When the select input is changed it will show only the skills at the selected level to the user. For example, if the user wants to review the 'halfbad' skills they would select 'halfbad' from our soon to be created dropdown and without having to refresh the page, we would want only the skills with a level of 'halfbad' to show up in our 
AllSkills
 component.


First let's create a SelectFilter component.

touch app/javascripts/components/_select_filter.js.jsx


In our 
_select_filter
 we will create a component that has a selector and label. Our 
SelectFilter
 class renders a Label, and a Select input with four options (all, bad, halfbad, and fantastic).


app/assets/components/javascripts/selectfilter.js.jsx

var SelectFilter = React.createClass({
  render (){
    return(
      

        
        
          All
          Bad
          Halfbad
          Fantastic
        
      

    )
  }
}






To make sure the 
SelectFilter
 component looks the way we want, we will add it to the 
Body
 component in our 
_body.js.jsx
 file, fire up the server (if you haven't yet done so) with 
rails s
, and then navigate to 
localhost:3000
.


app/assets/components/javascripts/_body.js.jsx

render() {
  return (
    

      
      
      
      

  )
}


If everything is wired up correctly, you should now see a select input with the four options in between the 
NewSkill
 form and the 
AllSkills
 list.


Now we will actually create our filtering functionality. The big picture is that we want to filter based on the level, so we will start our journey by passing a 
handleFilter
 property to our 
SelectFilter
 component. This property we will call whenever we want to actually filter our skills, so we need to assign it a callback - 
this.filterSkillsByLevel
.


app/assets/components/javascripts/_body.js.jsx

render() {
  return (
    

      
      
      
      

  )
}




I am sure you noticed that inside of our 
handleFilter
 property we have a function called 
filterSkillsByLevel
, so let's go ahead and create that within our 
_body.js.jsx
.


app/assets/components/javascripts/_body.js.jsx

filterSkillsByLevel(level) {
  console.log("about to filter");
},


We will add the functionality of filtering in the above 
filterSkillsByLevel(level)
 function. But first, let's wire it all together and make sure that when the user changes the select dropdown, this 
filterSkillsByLevel
 function is invoked.


Let's add an 
onChange
 event to our select input that will call the 
updateFilter
 function. In order to accomplish that we must bind the object 'this' to our function call. In this case, the 'this' object refers to the 
SelectFilter
 component. This is important because if we did not bind 'this', when we get into the updateFilter function call we would not be able to call 
this.state
 or 
this.props
 since in that case, this would refer to the function 
updateFilter
, not the component 
SelectFilter
. That is a lot of this's and thats and for what its worth, this is probably the toughest part of React!


app/assets/components/javascripts/selectfilter.js.jsx
```
render (){
  return(
    

      
        
...

Now we need to create an updateFilter function within the FilterSelect component which will be invoked whenever there is a change on our element.

app/assets/components/javascripts/_select_filter.js.jsx

updateFilter(event) {
  this.props.handleFilter(event.target.value)
}


Remember, since we bound the object 'this' to the function call in our `updateFilter`, 'this' refers to the entire component. This gives us access to all of the properties of the `SelectFilter` component. We need the `handleFilter` property, which we pass into the component when we render it in the Body. The `handleFilter` property points to the `filterSkillsByLevel` function in the `Body` component.

         Main
       /      \
  Header        Body
            /      \                 \
        NewSkill   SelectFilter    AllSkills
                                       \
                                      Skills * n
``
For additional context, in the above diagram when the user selects a value to filter by in theSelectFiltercomponent, thehandleFilterproperty is invoked which sends a message up to thebodycomponent. This message then changes the state of ourbody` component which in turn re-renders the list of visible skills.

Let's pass in the value of the select input from the 
SelectFilter to the Body, which we get from the event object.

event.target.value

If everything is working properly, when you reload the page and select an option from the selector, you should see "about to filter" logged to the console.

Next we need to actually make the 
filterSkillsByLevel function filter our skills list based on the value passed in from the select input. Let's start by creating a variable called newSkills which will represent the skills we want to display for our user based on the selected level in our SelectFilter component.

app/assets/components/javascripts/_body.js.jsx


filterSkillsByLevel(level) {
  let newSkills = null;
}

If the selected level does not equal all, then we want to filter the skills stored in this.state.skills based on the selected level.

app/assets/components/javascripts/_body.js.jsx


filterSkillsByLevel(level) {
  let newSkills = null;
  if (level !== 'all') {
    let newSkills = this.state.skills.filter(skill => skill.level === level);
  }
}

Now if the level passed in to our filterSkillsByLevel function is 'all' newSkills will be null, which is falsey. Otherwise it will be an array of skills with level equal to the passed in level. All we need to do is set the state of our app like this:

app/assets/components/javascripts/_body.js.jsx


filterSkillsByLevel(level) {
  let newSkills = null;
  if (level !== 'all') {
    let newSkills = this.state.skills.filter(skill => skill.level === level);
  }
  this.setState({filteredSkills: newSkills});  
},


We are also going to add the 
filteredSkills property to our initizalize function. We do this to show explicitely what the initial state of our component should be.

app/assets/components/javascripts/_body.js.jsx


getInitialState() {
  return { skills: [], filteredSkills: null }
},


The last thing we need to do is selectively render all the skills in 
this.state.skills if there is no filter being applied (e.g. 'all' is selected) or render the skills in this.state.filteredSkills. To do this we are going to use the || operator which will return the value on the left side if it is truthy and otherwise return the value on the right. Looking at our render function in our Body component we'll make the following change in how we render the AllSkills component:



In the above code, when the AllSkills component is rendered, it will first set the property skills. To do so it will look at this.state.filteredSkills. If this.state.filteredSkills is truthy it will take this.state.filteredSkills for the skills property. Otherwise it will store this.state.skills as the skills property.


this.state.filteredSkills will be null when the component is first rendered, so it will evaluate to be false. It will also be null when the user selects 'all' from the selectFilter component. In both of these cases, the AllSkills component will render with this.state.skills or all the skills as its skills property.

However, if a filter value is selected, 
this.state.filterSkills will be an array of filtered skills and therefore evaluate to be true. In that case, the AllSkills component will render with the filtered skills stored in this.state.filterSkills as its skills property.

All together our updated render function will look like this:

app/assets/components/javascripts/_body.js.jsx


render() {
    return (
      
        
        
        
      
    )
  }

Now we have a very snappy feeling filter function. We did it!

13. You are awesome





Possible extensions:


extract out API calls to service
add styling (use className instead of class when adding CSS classes)
filter skills by level (3 click events on 3 buttons which hides non matching skills)
filter skills by text (use onChange event handler)
tag skills (personal, professional, urgent)
create groups of skills


If you are interested in adding sections to this tutorial or find areas for improvement/correction/clarification, please submit a pull request.



  
   
   
   
   



 We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.