Can we throw here if the value passed is not a hash or a string? What else could the value be?

djudji [1:57 AM]
OK, so this is the thing, the code brakes at AppointmentsList component, after the update. It gives an appointments.map is not a function error, which means that it can not iterate over the Object type (edited)

[1:59]
@justin any recommendations?

djudji [3:31 AM]
could it be a new way of passing data from Rails to React (as I am testing more and more, it looks like props is not getting the right values from a controller)?

djudji [3:53 AM]
it hangs inside function render(el, railsContext) in clientStartup.js

[3:55]
this is how I am sending the data to a React component
react_component 'Appointments', props: {appointments: @appointments}

[3:56]
and on "the other side" I get
Object {appointments: "#<Appointment::ActiveRecord_Relation:0x007f972440cb90>"}
instead of an array of Objects, like before updating to 6.9.1 (edited)

justin [8:16 AM]
Dev or production. Please try both.

djudji [9:49 AM]
Currently on dev. Will try it in production again (first app didn't work because I haven't set a new version for react_on_rails in package.json)

OK, this is a bit strange.

1. I cloned non-updated app
2. I did upgrade to react_on_rails 6.9.1
3. Created a new heroku app and pushed the upgraded app to Heroku.

Now everything is working fine in production, but in dev I still have the same error.

This is the URL -> https://calendar-react-on-rails.herokuapp.com/

I can confirm that both of the apps work when pushed to production.

This is the first URL -> https://calendar-railsreact.herokuapp.com/ (edited

the error is in the conversion to the pretty JSON… for development mode.

   if Rails.env.development?
     # TODO: for json_safe_and_pretty
     # 1. Add test
     # 2. Add error handler if cannot parse the string with nice message
     # 3. Consider checking that if not a string then a Hash
     hash_value = hash_or_string.is_a?(String) ? JSON.parse(hash_or_string) : hash_or_string
     ERB::Util.json_escape(JSON.pretty_generate(hash_value))
   else
     ERB::Util.json_escape(hash_or_string.to_json)
   end
 end

Before, we used to call:

    props.is_a?(String) ? json_escape(props) : props.to_json
  end```


So I think if a Hash is passed, rather than a string, and we want to pretty print, then we’d have to go:

1. Hash => to_json (converts active record objects) => String
2. String => Hash
3. Then call `ERB::Util.json_escape(JSON.pretty_generate(hash_value))`

This could be a little slow.

1. Wondering if this should be optional, in `config/initializers/react_on_rails.rb`
2. Another option is skip pretty printing completely (but then should make an option).
</blockquote></details>

currently decided not to use pretty generate

---

*[app/helpers/react_on_rails_helper.rb, line 231 at r2](https://reviewable.io:443/reviews/shakacode/react_on_rails/787#-KgcggrDdvDqTLt3uR8q:-KhSNfG5p3IgHg_wp0bx:b-vjole3) ([raw file](https://github.com/shakacode/react_on_rails/blob/a3ef532d26039dc87d3032142a3171a6d26b2f3a/app/helpers/react_on_rails_helper.rb#L231)):*
<details><summary><i>Previously, justin808 (Justin Gordon) wrote…</i></summary><blockquote>

Can we move this catch block around the JSON.parse above?

we can do something like:

```ruby
  hash_value = if hash_or_string.is_a?(String) 
                          begin
                              JSON.parse(hash_or_string)
                           rescue JSON::ParserError => e
                               raise e, %(Cannot parse #{hash_or_string} \n Backtrace: #{e.backtrace.join("\n")})
                          else
                              hash_or_string
                          end  

Can you provide a comment with a link on to the github source of this?

Can we add a couple tests that confirm the exceptions:

1. non-hash, non-string passed
2. non parseable string in development mode

Also, we're never testing the part where we check we're in development mode.

I'd try to mock/stub out the Rails.env for that test.

# RSpec version
it 'tests my code' do
  allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new('development'))
  # test code
end

Some options from Google