adva_cells 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a31acd0faa774a966b3b3e5d7ffcde47a1d2c72a
+  data.tar.gz: e03500610437b0c644ef3964222fd5c398836931
+SHA512:
+  metadata.gz: 2a8f443c48f1f8cf1a38f05456e041a10be84c82a538f2095fe36d06853d78151da9a763bcdab37586adba6cf51ac59c03ab259e92d10f266cee739a2b0e0139
+  data.tar.gz: 494eb02234bc920f62f4efab7198973394cdfa6ec5d6730a0f6efe125d62538aba0e9cd63d169380695bfdde2e8989ac0bb26b5702df2f191272bbdcf446a8e9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in adva_cells.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Micah Geisel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# AdvaCells
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'adva_cells'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install adva_cells
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/adva_cells.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/adva_cells/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Micah Geisel"]
+  gem.email         = ["micah@botandrose.com"]
+  gem.description   = %q{Adva Cells}
+  gem.summary       = %q{Engine for Adva CMS embedable cells}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "adva_cells"
+  gem.require_paths = ["lib"]
+  gem.version       = AdvaCells::VERSION
+
+  gem.add_dependency "cells"
+  gem.add_dependency "tilt"
+end

data/app/cells/base_cell.rb

@@ -0,0 +1,83 @@
+require "cells"
+require "cell/base"
+require "tilt"
+
+class BaseCell < Cell::Base
+  def self.to_xml(options={})
+    options[:root]    ||= 'cell'
+    options[:indent]  ||= 2
+    options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+    cell_name = self.to_s.gsub('Cell', '').underscore
+
+    options[:builder].tag!(options[:root]) do |cell_node|
+      cell_node.id   cell_name
+      cell_node.name cell_name.humanize
+      cell_node.states do |states_node|
+        self.action_methods.each do |state|
+          states_node.state do |state_node|
+            state = state.to_s
+
+            template_path = "#{view_paths.first}/#{cell_name}/#{state}_form.html*"
+            possible_templates = Dir.glob(template_path)
+            template = possible_templates.first
+            form = template ? Tilt.new(template).render : ''
+
+            state_node.id          state
+            state_node.name        state.humanize
+            state_node.description I18n.translate(:"adva.cells.#{cell_name}.states.#{state}.description", :default => '')
+            state_node.form        form
+          end
+        end
+      end
+    end
+  end
+
+  def self.to_json
+    cell_name = self.to_s.sub("Cell", "").underscore
+    action_methods.map do |state|
+      {
+        id:   "#{cell_name}/#{state.to_s}",
+        name: "#{cell_name.humanize} #{state.to_s.humanize}",
+      }
+    end
+  end
+
+  protected
+
+  def symbolize_options!
+    @opts.symbolize_keys!
+  end
+
+  def set_site
+    @site = controller.site or raise "can not set site from controller"
+  end
+
+  def set_section
+    if section = @opts[:section]
+      @section = @site.sections.find(:first, :conditions => ["id = ? OR permalink = ?", section, section])
+    end
+    @section ||= controller.section
+    @section ||= @site.sections.root
+  end
+
+  # TODO make this a class level dsl, so cells can say something like:
+  # has_option :include_child_section => {:type => :boolean, :default => true}
+  def include_child_sections?
+    boolean_option(:include_child_sections)
+  end
+
+  def boolean_option(key)
+    value = @opts[key]
+    !!(value.blank? || value == 'false' || value == '0' ? false : true)
+  end
+
+  def with_sections_scope(klass, &block)
+    conditions = include_child_sections? ?
+      ["(sections.lft >= ?) and (sections.rgt <= ?)", @section.lft, @section.rgt] :
+      { :section_id => @section.id }
+    options = { :find => { :conditions => conditions, :include => 'section' }}
+
+    klass.send :with_scope, options, &block
+  end
+end

data/app/controllers/admin/cells_controller.rb

@@ -0,0 +1,10 @@
+class Admin::CellsController < Admin::BaseController
+  def index
+    @cells = Cell.all
+
+    respond_to do |format|
+      format.xml  { render :xml => @cells.to_xml(:root => 'cells', :skip_types => true) }
+      format.json { render :json => { cells: @cells.map(&:to_json).flatten } }
+    end
+  end
+end

data/app/helpers/contact_mailer_helper.rb

@@ -0,0 +1,7 @@
+module ContactMailerHelper
+  def render_fields(fields)
+    builder = ContactMailFormBuilder.new
+    fields.each { |field| builder.add_field(field.symbolize_keys!) }
+    builder.render_fields
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+  namespace :admin do
+    get "cells" => "cells#index"
+  end
+end
+

data/lib/adva_cells.rb

@@ -0,0 +1,13 @@
+# require "adva_cells/version"
+require "rails"
+require "cells"
+require "cells_ext"
+require "output_filter/cells"
+
+module AdvaCells
+  class Engine < Rails::Engine
+    initializer "adva_cells.init" do |app|
+      app.config.middleware.use "OutputFilter::Cells"
+    end
+  end
+end

data/lib/adva_cells/version.rb

@@ -0,0 +1,3 @@
+module AdvaCells
+  VERSION = "0.0.1"
+end

data/lib/cells_ext.rb

@@ -0,0 +1,18 @@
+module Cell
+  class << self
+    def all
+      @all ||= begin
+        require_all_cells
+        BaseCell.subclasses
+      end
+    end
+
+    private
+
+    def require_all_cells
+      # TODO pull in cells from engines, too
+      cell_files = Dir[::Rails.root.join('app/cells/*.rb')]
+      cell_files.each { |cell_file| require cell_file }
+    end
+  end
+end

data/lib/contact_mail_form_builder.rb

@@ -0,0 +1,178 @@
+class ContactMailFormBuilder
+  def add_fields(fields)
+    fields.each do |field|
+      add_field(field)
+    end
+  end
+
+  def add_field(field)
+    fields << case field[:type]
+      when 'header'       then Tags::Header.new(field) 
+      when 'text_field'   then Tags::TextField.new(field)
+      when 'text_area'    then Tags::TextArea.new(field)
+      when 'radio_button' then Tags::RadioButton.new(field)
+      when 'check_box'    then Tags::CheckBox.new(field)
+      when 'select'       then Tags::Select.new(field)
+      else ''
+    end
+  end
+
+  def fields
+    @fields ||= []
+  end
+
+  def render_fields
+    html = ""
+    fields.collect do |field|
+      if field.valid?
+        if field.is_a?(Tags::Header)
+          html += "\n" + field.render + "\n"
+        else
+          html += "<p>\n" + field.render + "</p>\n"
+        end
+      end
+    end
+    html
+  end
+end
+
+module Tags
+  class Base
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+    include ActionView::Helpers::TagHelper
+    
+    attr_accessor :options
+    
+    def initialize(options = {})
+      @options = options[:options] || {}
+    end
+    
+    def type
+      self.class.to_s.sub(/Tags::/, '')
+    end
+    
+    def valid?
+      true
+    end
+    
+    def render
+      ""
+    end
+  end
+  
+  class FormFieldBase < Base
+    attr_accessor :name, :label, :value
+    
+    def initialize(options = {})
+      super
+      @name    = options[:name]
+      @value   = options[:value]
+      @label   = options[:label]
+    end
+    
+    def valid?
+      !!name
+    end
+    
+    def label_for
+      field = label ? label : name.capitalize
+      "\t<label for='contact_mail_#{dehumanize(field)}'>#{field}</label>\n"
+    end
+    
+    def dehumanize(string)
+      string.gsub(/([^A-Za-z0-9_])/, "_").gsub(/([_.][_.]+)/, "_").gsub(/(^[_.]|[_.]$)/, "").downcase
+    end
+    
+    def dehumanized_name
+      :"contact_mail[#{dehumanize(name)}]"
+    end
+    
+  end
+  
+  class CheckableBase < FormFieldBase
+    attr_accessor :checked
+    
+    def initialize(options = {})
+      super
+      @checked = options[:checked]
+    end
+  end
+  
+  class TextField < FormFieldBase
+    def render
+      label_for + "\t" + text_field_tag(dehumanized_name, value, options) + "\n"
+    end
+  end
+  
+  class TextArea < FormFieldBase
+    def text_area_options
+      options[:id] ? options : options.merge(:id => "contact_mail_#{name}")
+    end
+    
+    def render
+      label_for + "\t" + text_area_tag(dehumanized_name, value, text_area_options) + "\n"
+    end
+  end
+  
+  class Select < FormFieldBase
+    attr_accessor :option_tags
+    
+    def initialize(options = {})
+      super
+      if options[:option_tags]
+        @option_tags = options[:option_tags].delete('option')
+      elsif options[:options] && options[:options]['option']
+        @option_tags = options[:options].delete('option')
+      else
+        @option_tags = {}
+      end
+    end
+    
+    def formatted_option_tags
+      option_tags.collect { |option| [option["label"], option["value"]] }
+    end
+    
+    def valid?
+      name && !option_tags.blank?
+    end
+    
+    def render
+      label_for + "\t" + select_tag(dehumanized_name, options_for_select(formatted_option_tags), options) + "\n"
+    end
+  end
+  
+  class RadioButton < CheckableBase
+    def valid?
+      name && value
+    end
+    
+    def render
+      label_for + "\t" + radio_button_tag(dehumanized_name, value, checked, options) + "\n"
+    end
+  end
+  
+  class CheckBox < CheckableBase
+    def render
+      label_for + "\t" + check_box_tag(dehumanized_name, value, checked, options) + "\n"
+    end
+  end
+  
+  class Header < Base
+    attr_accessor :title, :level
+    
+    def initialize(options = {})
+      super
+      @title = options[:title]
+      @level = options[:level] || 1
+    end
+    
+    def valid?
+      (1..6).include?(level.to_i)
+    end
+    
+    def render
+      content_tag(:"h#{level}", title, options)
+    end
+  end
+end

data/lib/output_filter/cells.rb

@@ -0,0 +1,48 @@
+module OutputFilter
+  class Cells
+    def initialize app
+      @app = app
+    end
+
+    def call env
+      status, headers, body = @app.call env
+      return [status, headers, body] unless headers["Content-Type"].try(:include?, "text/html")
+
+      new_body = ""
+      body.each { |part| new_body << part }
+      process! new_body
+      headers["Content-Length"] = new_body.length.to_s
+      [status, headers, [new_body]]
+    end
+
+    private
+
+    def process! body
+      cells = cells body
+
+      body.gsub!(/(#{cells.keys.join('|')})/) do |tag|
+        name, state, attrs = cells[tag]
+        attrs = HashWithIndifferentAccess.new(attrs)
+        cell = "#{name.camelize}Cell".constantize.new
+        args = [state]
+        attrs.delete "class" # ignore styling class
+        args << attrs unless attrs.empty?
+        begin
+          cell.render_state *args
+        rescue AbstractController::ActionNotFound
+          "<strong>Cell “#{name.capitalize} #{state}” not found!</strong>"
+        end
+      end unless cells.empty?
+    end
+
+    def cells body
+      body.scan(/(<cell[^>]*\/\s*>|<cell[^>]*>.*?<\/cell>)/m).inject({}) do |cells, matches|
+        tag = matches.first
+        attrs = Hash.from_xml(tag)['cell']
+        name, state = attrs.delete('name').split('/')
+        cells[tag] = [name, state, attrs]
+        cells
+      end
+    end
+  end
+end