dead_simple_cms 0.9.0

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Aryk Grosz
+
+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,266 @@
+Dead Simple CMS
+======
+
+Dead Simple CMS is a library for modifying different parts of your website without the overhead of having a
+fullblown CMS. The idea with this library is simple: provide an easy way to hook into different parts of your
+application (not only views) by defining the different parts to modify in an easy, straight-forward DSL.
+
+The basic components of this library include:
+
+ * A DSL to define the changeable values in your app
+ * Form generators based on SimpleForm (with or without Bootstrap) and default rails FormBuilder
+ * Expandable storage mechanisms so you can store the data in different locations
+   * Currently supported: Redis, Database, Memcache, even Memory (for testing)
+ * Presenters/renderers so you can take groups of variables and render them into your views (ie image_tag)
+
+What it doesn't have:
+
+ * Versioning - be able to look at old versions of the content
+ * Timing - set start and end time for different content
+ * Page builder tools - this is not the right tool if you want to design full pages
+
+Setup
+------------
+
+If you're Redis store isn't persistence, you can use the default option of using the database.
+If you decide to use the database, you can create the schema with this:
+
+```ruby
+  create_table :dead_simple_cms, :force => true do |t|
+    t.string :key
+    t.text :value
+    t.timestamps
+  end
+  add_index :dead_simple_cms, :key, :unique => true
+```
+
+Now, let's add the controller methods. Find a controller you want to use for your CMS:
+
+```ruby
+class Admin::CmsController < Admin::ApplicationController
+
+  include DeadSimpleCMS::Rails::ActionController::Extensions
+
+  cms_cache_sweeper :only => :edit
+
+  def edit
+    if request.post?
+      sections_updated = update_sections_from_params
+      redirect_to :action => :edit
+    end
+  end
+
+end
+```
+
+In your CMSHelper, add the view helper methods:
+
+```ruby
+module Admin
+  module CmsHelper
+    include DeadSimpleCMS::Rails::ActionView::Extensions
+  end
+end
+```
+
+This will give you access to the CMS presenter:
+
+```ruby
+def dead_simple_cms
+  @dead_simple_cms ||= Presenter.new(self)
+end
+```
+
+From here you can do:
+
+```ruby
+<%= dead_simple_cms.with_bootstrap_tabs %>
+```
+
+to render the forms for the different sections along with tabs to switch between them.
+
+Or, if you don't have bootstrap installed, you can use the default form builder and simply call:
+
+```ruby
+<%= dead_simple_cms.sections %>
+```
+
+Configuration
+-------------
+
+Create an initializer for your app in lib/config/initializers/dead_simple_cms. You can overwrite any of the original
+settings.
+
+```ruby
+DeadSimpleCMS.configure do
+
+  default_form_builder :simple_form_with_bootstrap
+
+  file_uploader_class Mixbook::DeadSimpleCMS::FileUploader
+
+  link_hint = "Please enter just the path (ie '/some-path')"
+
+  # In the group_configuration you can create configurations to use to bootstrap other groups. See below.
+  group_configuration(:image_tag) do
+    image :url, :required => true
+    string :alt, :default => "Design Beautiful Books"
+    string :href, :hint => link_hint, :required => true
+
+    # To render the display, just call #render with the instance of the view.
+    #
+    #  <%= group.render(self, {:class => "hi there"}, :alt => "alt value") %>
+    display do |group, html_options, image_html_options|
+      (image_html_options ||= {}).reverse_merge!(:alt => group.alt)
+      link_to_if(group.href, image_tag(group.url, image_html_options), group.href, html_options)
+    end
+  end
+
+  section(:application) do
+    group(:settings) do
+      [:option1, :option2, :options3].each do |setting|
+        boolean setting
+      end
+    end
+  end
+
+  section(:products_page, :path => "/products") do
+    [:left, :center, :right].each do |pos|
+      group(pos) do
+        image :url, :width => 272, :height => 238, :default => "/images/products_lander/products_1.jpg"
+        # You can provide a default value as well, for when the CMS starts up.
+        string :header, :default => "#{pos.to_s.titleize} Header"
+        
+        # Define a collection on "string", "integer" or "numeric" types if you want to limit the user to only a couple 
+        # of options. You can pass in an array or a lambda which yields an array (for deferred instantiation).
+        string :product_scope, :collection => lambda { SomeTable.all.map(&:product_scope) },
+          :default => "books"
+          
+        string :href, :hint => link_hint
+      end
+    end
+  end
+
+  # Here we create another CMS section for the cards page. I can define the :fragments to sweep in either a Hash
+  # or a lambda with the section yielded.
+  section(:cards_page, :path => "/cards",
+    :fragments => lambda { |section| {:controller => "/some_controller", :action => :index, :product_type => "cards", :section => section} }) do
+
+    # Here, we leverage the :image_tag group_configuration from above. Any values that are already present will be 
+    # overwritten by the values below.
+    group(:hero => :image_tag, :attribute_options => {
+      :url => {:width => 715, :height => 301, :default => "/images/storefront/design_beautiful_wedding_invitations.jpg"},
+      :alt   => {:default => "Design Beautiful Books"},
+      :href  => {:hint => link_hint, :default => "cards/wedding-invitations"}
+    })
+  end
+
+  section(:site_announcement, :path => "/") do
+    boolean :show_default, :default => false
+    [:current, :default].each do |type|
+      group(type) do
+        string :coupon_code
+        group(:top_bar) do
+          string :css_class, :collection => %w{facebook default christmas green}, :default => "facebook"
+          string :strong, :default => "FREE Priority Shipping on Orders $50+"
+          string :normal
+          string :action
+          string :href
+          
+          # Here we can display custom presenter for this content. The presenter class must respond_to "render"
+          # with the current template as the first arg, and any other arguments afterwards.
+          display Mixbook::DeadSimpleCMS::Presenters::SiteAnnouncement::TopBarPresenter
+        end
+        group :banner => :image_tag, :width => width, :height => height do
+          boolean :show
+          string :promotional_href, :hint => "Used for all custom coupon banners not from the site announcement."
+          display Mixbook::DeadSimpleCMS::Presenters::SiteAnnouncement::BannerPresenter
+        end
+      end
+    end
+  end
+
+end
+```
+
+For the view presenters, inherit from the `::DeadSimpleCMS::Group::Presenter`:
+
+```ruby
+# Public: Handles the banners on the site.
+class BannerPresenter < ::DeadSimpleCMS::Group::Presenter
+
+  attr_reader :coupon, :options, :size
+
+  def render
+    return unless coupon
+    url, alt, href, show, html_options = if coupon.same_code?(site_announcement.coupon_code)
+      [group.url, group.alt, group.href, group.show, {}]
+    else
+      url = "http://www.gettyimages.com/basketball.jpg"
+      [url, nil, group.promotional_href, true, {:onerror => "$(this).hide()"}]
+    end
+
+    # We can use any method accessible from the template since we simply delegate to the template.
+    link_to_if(href, image_tag(url, html_options.update(:class => "banner", :alt => alt)), href) if show
+  end
+
+  private
+
+  def initialize_extra_arguments(coupon, options={})
+    @coupon, @options = coupon, options
+    @size = options.delete(:size) || :small # Currently we have two sizes for these banners: 715x85 and 890x123. - Aryk
+    raise("Invalid size: #{size}") unless [:small, :large].include?(size)
+  end
+
+end
+```
+
+Then in your views, you can do:
+
+```ruby
+<%= DeadSimpleCMS.sections.current.banner.render(self, coupon, :size => :large) %>
+```
+
+For the file uploader, simply extend from ::DeadSimpleCMS::FileUploader::Base and add #url and #upload! methods.
+
+```ruby
+class Mixbook::DeadSimpleCMS::FileUploader < ::DeadSimpleCMS::FileUploader::Base
+
+  def url
+    # this should retrieve the url to where the photo will be uploaded to.
+  end
+
+  def upload!
+     AWS::S3::S3Object.store(path, data, "mybucket", :access => :public_read)
+  end
+
+end
+```
+
+Accessing Values
+-----
+
+To access the values and modify them directly:
+
+```ruby
+DeadSimpleCMS.sections.section1.group1.group2.group3.attribute = "new value"
+DeadSimpleCMS.sections.section1.save!
+
+# Access the data:
+DeadSimpleCMS.sections.section1.group1.group2.group3.attribute # => "new value"
+DeadSimpleCMS.sections.section1.groups[:group1].groups[:group2].attributes[:attribute].value # => "new value"
+```
+
+Meta
+----
+
+Dead Simple CMS was originally written in two days and came out of the real business
+needs of [mixbook.com](http://www.mixbook.com).
+
+We're based in Palo Alto (near California Ave) and we're hiring. We like dogs, beer, and music. If you're passionate
+(read: anal) about creating high quality products that makes people happy, please reach out to us at jobs@mixbook.com.
+
+
+Author
+------
+
+Aryk Grosz :: aryk.grosz@gmail.com :: @arykg

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+# RSpec 2.0
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs'
+task :default => :spec
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new('rcov') do |t|
+  t.pattern   = "spec/**/*_spec.rb"
+  t.rcov      = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/dead_simple_cms.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dead_simple_cms/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Aryk Grosz"]
+  gem.email         = ["aryk@mixbook.com"]
+  gem.summary       = %q{DeadSimpleCMS provides a way to define, modify, and present custom variables and content in your application.}
+  gem.homepage      = "http://github.com/Aryk/dead_simple_cms"
+
+  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          = "dead_simple_cms"
+  gem.require_paths = ["lib"]
+  gem.version       = DeadSimpleCMS::VERSION
+
+  gem.test_files = Dir["spec/**/*"]
+
+  gem.add_dependency "activesupport", ">= 3.0"
+  gem.add_dependency "activemodel",   ">= 3.0"
+
+  gem.add_development_dependency "simple_form"
+  gem.add_development_dependency "rails", ">= 3.0"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "sqlite3"
+
+  gem.description = <<-description
+Dead Simple CMS is a library for modifying different parts of your website without the overhead of having a
+fullblown CMS. The idea with this library is simple: provide an easy way to hook into different parts of your
+application (not only views) by defining the different parts to modify in an easy, straight-forward DSL.
+
+The basic components of this library include:
+
+ * A DSL to define the changeable values in your app
+ * Form generators based on SimpleForm (with or without Bootstrap) and default rails FormBuilder
+ * Expandable storage mechanisms so you can store the data in different locations
+   * Currently supported: Redis, Database, Memcache, even Memory (for testing)
+ * Presenters/renderers so you can take groups of variables and render them into your views (ie image_tag)
+
+What it doesn't have:
+
+ * Versioning - be able to look at old versions of the content
+ * Timing - set start and end time for different content
+ * Page builder tools - this is not the right tool if you want to design full pages
+  description
+
+end

data/lib/dead_simple_cms.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+require "dead_simple_cms/version"
+
+module DeadSimpleCMS ; end
+
+# These are the only two things needed from the rails family to run this. ActiveModel is necessary for observing and
+# callbacks done in the DeadSimpleCMS::Section class.
+require 'active_support/core_ext'
+require 'active_model'
+
+require 'dead_simple_cms/configuration'
+
+require 'dead_simple_cms/util/identifier'
+require 'dead_simple_cms/file_uploader/base'
+
+require 'dead_simple_cms/storage/base'
+require 'dead_simple_cms/storage/memory'
+module DeadSimpleCMS::Storage
+  autoload :RailsCache, 'dead_simple_cms/storage/rails_cache'
+  autoload :Redis,      'dead_simple_cms/storage/redis'
+  autoload :Database,   'dead_simple_cms/storage/database'
+end
+
+require 'dead_simple_cms/attribute/collection'
+
+require 'dead_simple_cms/attribute/type/collection_support'
+require 'dead_simple_cms/attribute/type/base'
+require 'dead_simple_cms/attribute/type/all'
+
+require 'dead_simple_cms/group'
+require 'dead_simple_cms/group/configuration'
+require 'dead_simple_cms/group/presenter'
+
+require 'dead_simple_cms/section'
+require 'dead_simple_cms/section/builder'
+
+if defined?(ActionView)
+  require 'dead_simple_cms/rails/action_view/form_builders/interface'
+  require 'dead_simple_cms/rails/action_view/form_builders/default'
+  module DeadSimpleCMS::Rails::ActionView::FormBuilders
+    autoload :SimpleForm,              'dead_simple_cms/rails/action_view/form_builders/simple_form'
+    autoload :SimpleFormWithBootstrap, 'dead_simple_cms/rails/action_view/form_builders/simple_form_with_bootstrap'
+  end
+
+  require 'dead_simple_cms/rails/action_view/extensions'
+  require 'dead_simple_cms/rails/action_view/presenter'
+end
+
+if defined?(ActionController)
+  require 'dead_simple_cms/rails/action_controller/extensions'
+  require 'dead_simple_cms/rails/action_controller/fragment_sweeper'
+end
+
+module DeadSimpleCMS
+
+  extend self
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def configure(&block)
+    configuration.instance_eval(&block)
+  end
+
+  def sections
+    @sections ||= Section.new_dictionary
+  end
+
+  def group_configurations
+    @group_configurations ||= Group::Configuration.new_dictionary
+  end
+
+  configure do
+
+    # Register any additional attribute classes for use in your configuration.
+    register_attribute_classes(Attribute::Type::String, Attribute::Type::Text, Attribute::Type::Numeric, Attribute::Type::Integer,
+      Attribute::Type::Boolean, Attribute::Type::File, Attribute::Type::Image, Attribute::Type::Symbol)
+
+    # Set the default form builder used for building the CMS forms in the app. You can replace this with :simple_form,
+    # :simple_form_with_bootstrap or pass in the actual builder class. Your builder class must include the interface:
+    # DeadSimpleCMS::Rails::ActionView::FormBuilders::Interface.
+    default_form_builder :default if defined?(ActionView)
+
+    # Set the default storage class for attributes to be store. The current available options are
+    # [:rails_cache, :database, :redis, :memory]. You can also extend DeadSimpleCMS::Storage::Base and provide your own.
+    # If you create your own, please provide the full class name.
+    #
+    # If you choose to use the database, make sure to create a database table to hold the data:
+    #      
+    #    create_table :dead_simple_cms, :force => true do |t|
+    #      t.string :key
+    #      t.text :value
+    #      t.timestamps
+    #    end
+    #    add_index :dead_simple_cms, :key, :unique => true
+    #
+    if defined?(ActiveRecord)
+      storage_class :database
+    else
+      puts "ATTENTION: DeadSimpleCMS did not find ActiveRecord. It will store the CMS in memory and you will lose it when your application shutsdown!!!"
+      storage_class :memory
+    end
+
+    # If you are going to use the 'file' type, make sure to provide an uploader class. By default file uploads
+    # **WILL NOT WORK**. Create your own uploader by extending from DeadSimpleCMS::FileUploader::Base and creating
+    # a #url and a #upload! method.
+    #
+    # Example
+    #
+    #   class MyFileUploader < DeadSimpleCMS::FileUploader::Base
+    #
+    #     def url
+    #       # This should retrieve the url to where the photo will be uploaded to.
+    #     end
+    #       
+    #     def upload!
+    #       AWS::S3::S3Object.store(path, data, "mybucket", :access => :public_read)
+    #     end
+    
+    #   end
+    #
+    #
+    # file_uploader_class MyOwnFileUploader
+
+    # Set the serializer class to use. It must output to a string and have #dump and #load methods on it.
+    require 'psych'
+    storage_serializer_class Psych
+
+  end
+
+end