Jbuilder vous offre un DSL simple pour déclarer des structures JSON qui va au-delà de la manipulation d’énormes structures de hachage. Ceci est particulièrement utile lorsque le processus de génération est chargé de conditions et de boucles. Voici un exemple simple:

# app/views/messages/show.json.jbuilder

json.content format_content(@message.content)
json.(@message, :created_at, :updated_at)

json.author do
  json.name @message.creator.name.familiar
  json.email_address @message.creator.email_address_with_name
  json.url url_for(@message.creator, format: :json)
end

if current_user.admin?
  json.visitors calculate_visitors(@message)
end

json.comments @message.comments, :content, :created_at

json.attachments @message.attachments do |attachment|
  json.filename attachment.filename
  json.url url_for(attachment)
end

Cela crée la structure suivante:

{
  "content": "<p>This is <i>serious</i> monkey business</p>",
  "created_at": "2011-10-29T20:45:28-05:00",
  "updated_at": "2011-10-29T20:45:28-05:00",

  "author": {
    "name": "David H.",
    "email_address": "'David Heinemeier Hansson' <[email protected]>",
    "url": "http://example.com/users/1-david.json"
  },

  "visitors": 15,

  "comments": [
    { "content": "Hello everyone!", "created_at": "2011-10-29T20:45:28-05:00" },
    { "content": "To you my good sir!", "created_at": "2011-10-29T20:47:28-05:00" }
  ],

  "attachments": [
    { "filename": "forecast.xls", "url": "http://example.com/downloads/forecast.xls" },
    { "filename": "presentation.pdf", "url": "http://example.com/downloads/presentation.pdf" }
  ]
}

Utilisez le pour définir dynamiquement les noms d’attributs et de structures set! Méthode:

json.set! :author do
  json.set! :name, 'David'
end

# => {"author": { "name": "David" }}

Pour fusionner un hachage ou un tableau existant avec le contexte actuel:

hash = { author: { name: "David" } }
json.post do
  json.title "Merge HOWTO"
  json.merge! hash
end

# => "post": { "title": "Merge HOWTO", "author": { "name": "David" } }

Les tableaux de niveau supérieur peuvent être gérés directement. Utile pour l’index et d’autres actions de capture.

# @comments = @post.comments

json.array! @comments do |comment|
  next if comment.marked_as_spam_by?(current_user)

  json.body comment.body
  json.author do
    json.first_name comment.author.first_name
    json.last_name comment.author.last_name
  end
end

# => [ { "body": "great post...", "author": { "first_name": "Joe", "last_name": "Bloe" }} ]

Vous pouvez également extraire des attributs directement du tableau.

# @people = People.all

json.array! @people, :id, :name

# => [ { "id": 1, "name": "David" }, { "id": 2, "name": "Jamie" } ]

Les objets Jbuilder peuvent être imbriqués les uns dans les autres. Utile pour créer des objets.

class Person
  # ... Class Definition ... #
  def to_builder
    Jbuilder.new do |person|
      person.(self, :name, :age)
    end
  end
end

class Company
  # ... Class Definition ... #
  def to_builder
    Jbuilder.new do |company|
      company.name name
      company.president president.to_builder
    end
  end
end

company = Company.new('Doodle Corp', Person.new('John Stobs', 58))
company.to_builder.target!

# => {"name":"Doodle Corp","president":{"name":"John Stobs","age":58}}

Vous pouvez utiliser Jbuilder seul ou directement comme langage de modèle ActionView. Si nécessaire dans Rails, vous pouvez créer des vues à la show.json.jbuilder (le json est déjà sorti):

# Any helpers available to views are available to the builder
json.content format_content(@message.content)
json.(@message, :created_at, :updated_at)

json.author do
  json.name @message.creator.name.familiar
  json.email_address @message.creator.email_address_with_name
  json.url url_for(@message.creator, format: :json)
end

if current_user.admin?
  json.visitors calculate_visitors(@message)
end

Vous pouvez également utiliser des partiels. Ce qui suit est le rendu du fichier
views/comments/_comments.json.jbuilderet définissez une variable locale
comments avec tous les commentaires de ce message que vous pouvez utiliser dans la pièce.

json.partial! 'comments/comments', comments: @message.comments

Il est également possible de rendre des collections de Partiels:

json.array! @posts, partial: 'posts/post', as: :post

# or

json.partial! 'posts/post', collection: @posts, as: :post

# or

json.partial! partial: 'posts/post', collection: @posts, as: :post

# or

json.comments @post.comments, partial: 'comments/comment', as: :comment

le as: :some_symbol est utilisé avec les partiels. Il est garanti que l’objet transféré est affecté à une variable pour la pièce. Si la valeur est une collection (implicitement ou explicitement en utilisant collection: Option, puis chaque valeur de la collection est transmise à la pièce en tant que variable some_symbol. Si la valeur est un objet unique, l’objet est passé à la pièce en tant que variable some_symbol.

Veillez à ne pas confondre ces as: Option pour désigner l’imbrication de la pièce. Par example:

 # Use the default `views/comments/_comment.json.jbuilder`, putting @comment as the comment local variable.
 # Note, `comment` attributes are "inlined".
 json.partial! @comment, as: :comment

est très différent de:

 # comment attributes are nested under a "comment" property
json.comment do
  json.partial! "/comments/comment.json.jbuilder", comment: @comment
end

Vous pouvez transférer tous les objets avec ou sans gabarits de pièces :locals Possibilité.

json.partial! 'sub_template', locals: { user: user }

# or

json.partial! 'sub_template', user: user

Vous pouvez renvoyer explicitement l’objet Jbuilder à null si vous le souhaitez:

json.extract! @post, :id, :title, :content, :published_at
json.author do
  if @post.anonymous?
    json.null! # or json.nil!
  else
    json.first_name @post.author_first_name
    json.last_name @post.author_last_name
  end
end

Vous pouvez utiliser le pour empêcher Jbuilder d’insérer des valeurs nulles dans la sortie ignore_nil! Méthode:

json.ignore_nil!
json.foo nil
json.bar "bar"
# => { "bar": "bar" }

La mise en cache des fragments est prise en charge, elle est utilisée Rails.cache et fonctionne comme la mise en cache dans les modèles HTML:

json.cache! ['v1', @person], expires_in: 10.minutes do
  json.extract! @person, :name, :age
end

Vous pouvez également mettre en cache conditionnellement un bloc en utilisant cache_if! comme ça:

json.cache_if! !admin?, ['v1', @person], expires_in: 10.minutes do
  json.extract! @person, :name, :age
end

Si vous restituer des fragments pour une collection d’objets, regardez-les
jbuilder_cache_multi Bijou. Il utilise fetch_multi (> = Rails 4.1) pour récupérer plusieurs clés en même temps.

Les clés peuvent être automatiquement formatées avec key_format!Cela peut être utilisé pour convertir les noms de clés du ruby_format standard en camelCase:

json.key_format! camelize: :lower
json.first_name 'David'

# => { "firstName": "David" }

Vous pouvez définir cela globalement avec la méthode de classe key_format (par exemple à partir de votre environnement.rb):

Jbuilder.key_format camelize: :lower

Par défaut, le format de clé n’est pas appliqué aux clés des hachages passés à des méthodes telles que set!, array! ou alors merge!. Vous pouvez également choisir de les transformer en profondeur:

json.key_format! camelize: :lower
json.deep_format_keys!
json.settings([{some_value: "abc"}])

# => { "settings": [{ "someValue": "abc" }]}

Vous pouvez définir cela globalement avec la méthode de classe deep_format_keys (par exemple à partir de votre environnement.rb):

Jbuilder.deep_format_keys true

Contribution à Jbuilder

Jbuilder est le travail de nombreux contributeurs. Il vous sera demandé de soumettre des pull requests, de proposer des fonctionnalités et de discuter des problèmes.

Voir CONTRIBUTION.

Licence

Jbuilder est publié sous le Licence MIT.



Source link

Recent Posts