Glia

gem 'glia'

# layout/frontend/default.rb
Glia.area(:frontend) do 
  view_namespace Fixtures::View
  handle :default do
    cell name: :root, class: :'core/html', template_name: 'root', missing_accessor: 'ignore_me' do
      cell name: :header, class: :template, template_name: 'header'
      cell name: :sidebar, class: :list do
        # ...
      end
      cell name: :footer, class: :template, template_name: 'footer'
    end
  end
  handle :cake_view do
    reference name: :root do
      cell name: :details, class: Fixtures::View::Template, template_name: 'cake_details', position: :content do
        cell name: :specifications, class: :list do
          cell name: :cake_specs, class: 'Template', template_name: 'cake/specs'
          cell name: :cake_ingredients, class: :template, template_name: 'cake/ingredients'
        end
      end
    end
  end
  handle :pavlova_view, :new_view do
    reference name: :specifications do
      remove name: :cake_specs
    end
    reference name: :cake_ingredients, template_name: 'cake/pavlova_ingredients' do
      action name: :add_ingredient, args: ['Eggs', '6 Large']
    end
  end
end

[:default, :cake_view, :pavlova_view]

[:default, :quotes, :quotes_show, :quotes_show_AJAX, :quote_show_TYPE_PLUMBING]

[:default, :sales_quotes, :sales_quotes_show]

Glia.area(:frontend) do 
  handle :pavlova_view do
    reference name: :specifications do
      remove name: :cake_specs
    end
    reference name: :cake_ingredients, template_name: 'cake/pavlova_ingredients' do
      action name: :add_ingredient, args: ['Eggs', '6 Large']
    end
  end
end

layout = Glia.layout(:frontend, [:default, :cake_view, :pavlova_view])
```

This returns an instance of Glia::Layout

### Render the layout.

Get the `:root` cell from the layout, and render it. The `render` method is provided by your view layer library/gem. 
Substitute the method name that you have. 

```ruby
layout.cell(:root).render
```

That is all. Your root cell's rendering process should be such that the child cells are picked out and rendered,
and those child cells pick out and render their child cells, and so on until the whole layout tree is rendered. 

## Suggestions

### Suggested Cell Types

* `Template` A generic cell that has a `template_name` and a data passed into its constructor in key/value pairs.
  It would render the template, using the data as locals. 
* `List` A generic cell that has no template, but instead renders all child cells 
  (DSL to control order of child cells to come soon). 
  These can be very handy for providing areas such as sidebars, where any number of cells can be added or removed 
  without having to have a `cell(:name).render` helper called for each specific child cell 
* `Html::Head` A cell with specific methods for including asset tags etc.
* Specific classes for cells that have their own logic. E.g. `Product::Price`, `Category::List` 

### Getting data to cells

Try one or more of these options:

* Pass the data as locals to each cell or child cell as you render it. 
* Create a registry (using e.g. [RequestStore](https://github.com/steveklabnik/request_store)), which the controller can
  pass data to, and the cells can read data from. 
* If more flexibility is required, the controller can pull a specific cell from the layout, and call a method on it. 

### Customise the ViewFactory

Example for Customised Lotus Views

```ruby
module Frontend
  class Application < Lotus::Application

    def renderer
      @custom_renderer ||= Client::RenderingPolicy.new(configuration)
    end

    configure do
      # ...
    end

  end
end
```

```ruby
require 'glia'
class Client::RenderingPolicy < Lotus::RenderingPolicy

  class ViewFactory < Glia::ViewFactory
    def instantiate(klass, definition, *args)
      #@todo: Allow blocks/cells to subscribe to registry values.
      locals = args[0].nil? ? definition : definition.merge(args[0])
      klass.new({format: :html}.merge(locals))
    end
  end

  def _render_action(action, response)
    @area ||= @namespace.name.downcase.to_sym
    if successful?(response)
      if response[BODY].empty?
        RequestStore.store[:action_exposures] = action.exposures
        layout = Glia.layout(@area, action.handles)
        layout.view_factory = ViewFactory.new
        layout.cell(:root, action.exposures).render
      else
        Lotus::Views::NullView.new(response[BODY]).render(action.exposures)
      end
    end
  end

end
```

## Theme Inheritance
In addition to areas, Glia provides a means to override the layouts with different 'themes'. 

For example. If your project serves multiple sites that each need a different header, you can achieve this with themes. 

```ruby
Glia::UpdateRegistry.area(:frontend, :default) do
  handle :default do
    cell name: :root, class: :html, template_name: 'root' do
      cell name: :header, class: :template, template_name: 'header'
      cell name: :footer, class: :template, template_name: 'footer'
    end
  end
end

Glia::UpdateRegistry.area(:frontend, :au) do
  handle :default do
    cell name: :root, class: :html, template_name: 'root' do
      cell name: :header, class: :template, template_name: 'header_au'
      remove name: :footer
    end
  end
end
```

When you get the layout, just specify which themes you want to merge. 

```ruby
layout = Glia.layout(:frontend, [:default, :product_view], theme_inheritance: [:default, :au])
```  

There is no limit to the number of themes you can use in the inheritance chain. 
It begins with the first theme, and applies updates from each successive theme.

## Notes
* When the DSL is parsed, the result is a simple hash of values that describes the layout. 

## Contributing

1. Fork it ( https://github.com/danelowe/glia/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request