ActiveRecord sérialiser en utilisant JSON au lieu de YAML

J'ai un modèle qui utilise un sérialisé colonne:

class Form < ActiveRecord::Base
  serialize :options, Hash
end

Est-il un moyen de rendre cette utilisation de la sérialisation JSON au lieu de YAML?

J'espérais qu'il y aurait une certaine "magie" ou de plugin, mais la solution est très simple et fonctionne très bien.
toby , vous pouvez changer la accepté de répondre à celui-ci? stackoverflow.com/a/6971678/190135 voir meta.stackexchange.com/questions/120568/...

InformationsquelleAutor Toby Hede | 2010-01-17

156

Dans les Rails 3.1, vous pouvez simplement
```
class Form < ActiveRecord::Base
  serialize :column, JSON
end
```
Espère que ça aide
- Je pense que c'est parce que [:dump, :load].all {|s| ::JSON.respond_to? s}, tout comme la valeur par défaut YAMLColumn n'. Dans un contrôleur, JSON == ::JSON et JSON != ::ActiveSupport::JSON.
- Cette travaillé à travers les Rails 3.2.1, mais il s'est arrêté avec 3.2.2: voir github.com/rails/rails/issues/5797 j'espère que c'est résolu, parce que c'est très pratique!
- C'est corrigé dans 3.2.5
- Sa fonctionne parfaitement pour moi en 3.2.3 ainsi
- Pour clarifier ce que @BenAtkin dit, si la Classe que vous passer dans la sérialiser appel répond à .dump(obj) et .load(obj) il sera utilisé en tant que codeur/sérialiseur. Sinon, la valeur par défaut YAMLColumn classe est utilisé en tant que codeur/sérialiseur. Le vidage de charge et de méthodes peuvent également être directement mis en œuvre dans une Classe de Modèle, vous n'avez pas pour pour utiliser une salle de classe distincte à faire le codage.
- De toute façon pour faire ce travail avec Rails 4?
- Cela peut provoquer l'erreur: NoMethodError: undefined method `read' for nil:NilClass
- Donc, ce vraiment plus rapide, puis standart YAML (ar4.1.4)
- Cela a fonctionné pour moi. J'avais besoin de ce parce que j'étais la migration vers les rails et la db avait déjà données en JSON. Ce doit être la accepté de répondre à
InformationsquelleAutor Justas L.
58

Dans les Rails 3.1 vous pouvez utiliser des codeurs avec serialize.
```
class ColorCoder
  # Called to deserialize data to ruby object.
  def load(data)
  end

  # Called to convert from ruby object to serialized data.
  def dump(obj)
  end
end

class Fruits < ActiveRecord::Base
  serialize :color, ColorCoder.new
end
```
Espère que cette aide.

Références:

Définition de serialize:
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/base.rb#L556

La valeur par défaut YAML codeur qui est livré avec des rails:
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/coders/yaml_column.rb

Et c'est là que l'appel à la load qui se passe:
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/attribute_methods/read.rb#L132
- S'il n'a pas été incorporé dans des Rails, au moment de l'écriture, une JSONColumn Codeur a contribué à Rails ici: gist.github.com/txus/rails/blob/... - pull request détails sont ici: gist.github.com/rails/rails/pull/196 . Espérons que cela aide ceux qui veulent utiliser serialize + JSON.
InformationsquelleAutor balu
11

Mise à jour

Voir le milieu de la haute note de réponse ci-dessous pour un beaucoup plus approprié Rails >= 3.1 réponse. C'est une excellente réponse pour les Rails < 3.1.

C'est probablement ce que vous cherchez.
```
Form.find(:first).to_json
```
Mise à jour

1) Installer 'json' gem:
```
gem install json
```
2) Créer JsonWrapper classe
```
# lib/json_wrapper.rb

require 'json'
class JsonWrapper
  def initialize(attribute)
    @attribute = attribute.to_s
  end

  def before_save(record)
    record.send("#{@attribute}=", JsonWrapper.encrypt(record.send("#{@attribute}")))
  end

  def after_save(record)
    record.send("#{@attribute}=", JsonWrapper.decrypt(record.send("#{@attribute}")))
  end

  def self.encrypt(value)
    value.to_json
  end

  def self.decrypt(value)
    JSON.parse(value) rescue value
  end
end
```
3) Ajouter le modèle rappels:
```
#app/models/user.rb

class User < ActiveRecord::Base
    before_save      JsonWrapper.new( :name )
    after_save       JsonWrapper.new( :name )

    def after_find
      self.name = JsonWrapper.decrypt self.name
    end
end
```
4) Tester!
```
User.create :name => {"a"=>"b", "c"=>["d", "e"]}
```
PS:

Ce n'est pas tout à fait SEC, mais j'ai fait de mon mieux. Si quelqu'un peut résoudre after_find dans User modèle, ça va être génial.
- Vous n'avez pas l'obtenir. Il veut :l'attribut options pour être sérialisés dans les données json, pas en yaml.
- Ja, à l'aide de sérialiser, les valeurs dans le champ des options sont stockés dans la base de données comme un YAML sérialisé de valeur. Je veux que, pour être JSON au lieu.
- Mise à jour de la réponse.
- "Crypter/décrypter" sont des noms trompeurs, car aucun la cryptographie est impliqué. Doit être "codage/décodage." Discutable maintenant de toute façon avec Rails 3.1 solution mentionnée ci-dessous.
InformationsquelleAutor St.Woland
8

Mes exigences n'ont pas besoin de beaucoup de code ré-utiliser à ce stade, donc, mon distillée code est une variation de la réponse ci-dessus:
```
  require "json/ext"

  before_save :json_serialize  
  after_save  :json_deserialize


  def json_serialize    
    self.options = self.options.to_json
  end

  def json_deserialize    
    self.options = JSON.parse(options)
  end

  def after_find 
    json_deserialize        
  end  
```
Acclamations, assez facile en fin de compte!
- Cela ne fonctionne qu'avec certains types de données. Par exemple input = 'foo'; serialized = input.to_json; JSON.parse(serialized) #=> JSON::ParserError: 757: unexpected token à " "toto"' de /Utilisateurs/nom_utilisateur/.rbenv/versions/2.2.2/lib/ruby/gems/2.2.0/gems/json-1.8.3/lib/json/commun.rb:155:dans `analyser' makandracards.com/makandra/... Une bonne solution pour cela est d'utiliser Ruby Maréchal de la bibliothèque. C'est plus rapide et plus fiable que le JSON ou YAML.
InformationsquelleAutor Toby Hede
3

J'ai écrit mes propres YAML codeur, qui prend une valeur par défaut. Ici, c'est la classe:
```
class JSONColumn
  def initialize(default={})
    @default = default
  end

  # this might be the database default and we should plan for empty strings or nils
  def load(s)
    s.present? ? JSON.load(s) : @default.clone
  end

  # this should only be nil or an object that serializes to JSON (like a hash or array)
  def dump(o)
    JSON.dump(o || @default)
  end
end
```
Depuis load et dump sont les méthodes d'instance, il requiert une instance d'être passé en second argument de la serialize dans la définition du modèle. Voici un exemple:
```
class Person < ActiveRecord::Base
  validate :name, :pets, :presence => true
  serialize :pets, JSONColumn.new([])
end
```
J'ai essayé de créer une nouvelle instance, le chargement d'une instance, et le dumping une instance de la CISR, et tout semblait fonctionner correctement. J'ai écrit un post de blog à ce sujet, aussi.
- Je suis vraiment nouveau dans les Rails. Où dois-je mettre le JSONColumn classe? Où aurais-je l'inclure? Merci!
- Il y a beaucoup de façons de le faire, mais voici une façon: vous pouvez le mettre dans lib/json_column.rb et ajouter require 'json_column' à config/environment.rb.
- Merci pour cette. Il est bon que vous pouvez définir une valeur par défaut. J'ai utilisé pour créer une colonne qui agit comme un ensemble (non ordonnée tableau): sérialiser :quelque chose, JsonSerializer.nouveau(Jeu.de nouvelles)
- D., si vous le nom de la classe afin qu'il corresponde au nom de fichier, alors vous n'avez même pas besoin de demander explicitement le fichier, car il va être chargés automatiquement lors de la première référence à la constante. Je l'ai appelé JsonSerializer et le mettre dans le répertoire lib/json_serializer.rb, donc je n'ai même pas besoin de demander d' 'json_serializer'. (Assurez-vous lib/ dans votre autoload_paths dans config/application.rb: config.autoload_paths = %W( #{config.racine}/lib ))
- que pourrait être la meilleure réponse pour l'instant. N'hésitez pas à écrire une nouvelle solution basée sur le mien. Pas besoin de me donner de l'attribution (ou plutôt que vous pouvez donner plus simple et la plus faiblement que vous le souhaitez). Par la présente, je libère ma réponse et le blog des liens vers elle dans le domaine public.
- meilleure réponse pour moi, pour une raison quelconque, la sérialisation w/ blobs+json ne pouvais pas initialiser le json dans Rails4rc1, cela me permet de le faire. Quelqu'un de connecté un problème github.com/rails/rails/pull/10830#issuecomment-18883754
InformationsquelleAutor Benjamin Atkin
3

La serialize :attr, JSON à l'aide de composed_of méthode fonctionne comme ceci:
```
  composed_of :auth,
              :class_name => 'ActiveSupport::JSON',
              :mapping => %w(url to_json),
              :constructor => Proc.new { |url| ActiveSupport::JSON.decode(url) }
```
où url est l'attribut d'être sérialisée en utilisant json
et auth est la nouvelle méthode de disponible sur votre modèle qui sauve sa valeur au format json à l'url de l'attribut. (pas entièrement encore testé, mais semble être le travail)

InformationsquelleAutor caribu
1

Une solution plus simple est d'utiliser composed_of comme décrit dans cet article de blog par Michael Rykov. J'aime bien cette solution, car elle nécessite l'utilisation de moins de rappels.

Voici l'essentiel:
```
composed_of :settings, :class_name => 'Settings', :mapping => %w(settings to_json),
                       :constructor => Settings.method(:from_json),
                       :converter   => Settings.method(:from_json)

after_validation do |u|
  u.settings = u.settings if u.settings.dirty? # Force to serialize
end
```
- Malheureusement, composed_of a été désapprouvée. blog.plataformatec.com.br/2012/06/sur-le-composed_of-suppression vous recommande d'utiliser un custom sérialiseur à la place.
InformationsquelleAutor Aleran
0

Aleran, avez-vous utilisé cette méthode avec Rails 3? J'ai un peu eu le même problème et j'ai été dirigeant vers sérialisé quand je suis tombé sur ce post par Michael Rykov, mais faire un commentaire sur son blog n'est pas possible, ou au moins sur ce poste. De ma compréhension, il est en train de dire que vous n'avez pas besoin de définir les Paramètres de la classe, cependant lorsque j'essaie de cela, il continue à me dire que le Paramètre n'est pas défini. Donc je me demandais si vous l'avez utilisé, et ce qui devrait avoir été décrit? Merci.
- Bien sûr, vous avez besoin de la Configuration de la classe. Mais vous pourriez probablement travailler directement sur la classe JSON. :constructeur => JSON.méthode(:parse), :convertisseur => JSON.méthode(:parse), :cartographie => %w(my_attribute to_json). N'essayez pas cela.
InformationsquelleAutor Andrew Lank

Vous devez vous connecter pour publier un commentaire.

PS: