dead_simple_cms 0.9.0

data/lib/dead_simple_cms/storage/base.rb

@@ -0,0 +1,49 @@
+module DeadSimpleCMS
+  module Storage
+    class Base
+
+      # Public: The serializer class used to convert the attributes hash into a String.
+      class_attribute :serializer_class
+
+      attr_reader :section
+
+      def initialize(section)
+        @section = section
+      end
+
+      # Public: Return a hash of the typed attributes from the data source.
+      def read
+        @_cache ||= (value = read_value) ? serializer_class.load(read_value) : {}
+      end
+
+      # Public: Write all the attributes of the section to it's data source. Returns the attributes_hash.
+      def write
+        hash = attributes_hash
+        write_value(serializer_class.dump(hash))
+        @_cache = hash # set @_cache after the write
+      end
+
+      # Public: Unique key for use in the storage mechanism.
+      def unique_key
+        @unique_key ||= section.identifier
+      end
+
+      private
+
+      # Public: Values to store.
+      def attributes_hash
+        attributes_hash = section.attributes.to_hash
+        attributes_hash.each { |k, attr| attributes_hash[k] = attr.value }
+      end
+
+      def read_value
+        raise(NotImplementedError, "Please provide a read_value method for #{self.class}")
+      end
+
+      def write_value(value)
+        raise(NotImplementedError, "Please provide a write_value method for #{self.class}")
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/storage/database.rb

@@ -0,0 +1,33 @@
+module DeadSimpleCMS
+  module Storage
+    class Database < Base
+
+      # Public: Table used to store the key/value pairs for the CMS
+      #
+      #   Structure
+      #      * key: varchar
+      #      * value: text
+      #
+      class Table < ActiveRecord::Base
+        self.table_name = "dead_simple_cms"
+        validates :key, :presence => true, :uniqueness => true
+      end
+
+      class_attribute :active_record
+      self.active_record = Table
+
+      private
+
+      def read_value
+        record = active_record.find_by_key(unique_key)
+        record && record.value
+      end
+
+      def write_value(value)
+        record = active_record.find_or_create_by_key(unique_key)
+        record.update_attribute(:value, value)
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/storage/memory.rb

@@ -0,0 +1,20 @@
+module DeadSimpleCMS
+  module Storage
+    # Public: Only used for testing and test-driving purposes. Once your application shutdown, you will lose the CMS information
+    class Memory < Base
+
+      @@cache = {}
+
+      private
+
+      def read_value
+        @@cache[unique_key]
+      end
+
+      def write_value(value)
+        @@cache[unique_key] = value
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/storage/rails_cache.rb

@@ -0,0 +1,19 @@
+module DeadSimpleCMS
+  module Storage
+    # Public: Store all the values in whatever is defined for the rails cache.
+    # Does not support storage of data with the value (ie no file storage support).
+    class RailsCache < Base
+
+      private
+
+      def read_value
+        ::Rails.cache.read(unique_key)
+      end
+
+      def write_value(value)
+        ::Rails.cache.write(unique_key, value, :expires_in => 5.years.from_now) # some really long time
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/storage/redis.rb

@@ -0,0 +1,23 @@
+module DeadSimpleCMS
+  module Storage
+    class Redis < Base
+      class << self
+        attr_writer :connection
+        def connection
+          @connection ||= (defined?(REDIS) && REDIS) || raise(NotImplementedError, "Redis connection not set.")
+        end
+      end
+
+      private
+
+      def read_value
+        self.class.connection.get(unique_key)
+      end
+
+      def write_value(value)
+        self.class.connection.set(unique_key, value)
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/util/identifier.rb

@@ -0,0 +1,40 @@
+require 'dead_simple_cms/util/identifier/dictionary'
+module DeadSimpleCMS
+  module Util
+
+    # Public: A module for the convention of having an identifier:
+    #
+    #  * an identifier (Symbol)
+    #  * a label (default: titleize) to present to the world
+    #  * a collection for looking up items based on their `identifier`
+    #
+    # We specifically got away from having a "name" as that usually leads to confusion. Is the name the "foo_bar" name or the
+    # pretty "Foo Bar" name?
+    module Identifier
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :label, :identifier
+      end
+
+      module InstanceMethods
+
+        def initialize(identifier, options={})
+          @identifier = identifier.to_sym
+          @label = options[:label] || identifier.to_s.titleize
+          super()
+        end
+
+      end
+
+      module ClassMethods
+
+        # Public: creates a new dictionary class.
+        def new_dictionary(*args, &block)
+          Dictionary.new(self, *args, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/util/identifier/dictionary.rb

@@ -0,0 +1,65 @@
+module DeadSimpleCMS
+  module Util
+    module Identifier
+      # Public: a dictionary of objects along with their identifiers. Since we are indexing by the identifier, we extend
+      # from Hash since that is our primary data store for the objects. We also enforce the condition that the values must
+      # be of a +target_class+.
+      class Dictionary < Hash
+        class DuplciateItem < StandardError ; end
+        class InvalidEntryClass < StandardError ; end
+
+        attr_reader :target_class, :identifier_method
+
+        def initialize(target_class, *args, &block)
+          options = args.extract_options!
+          @identifier_method = options[:identifier_method] || :identifier
+          @target_class = target_class
+          super(*args, &block)
+        end
+
+        def identifiers
+          keys
+        end
+
+        # Public: Convenience method for adding item by it's identifier.
+        def add(item)
+          self[to_identifier(item)] = item
+        end
+
+        def include?(key)
+          key?(to_identifier(key))
+        end
+
+        def to_hash
+          Hash[self]
+        end
+
+        # Public: set a record for the dictionary.
+        #
+        #  * If the value is not of type target_class, raise an error.
+        #  * If the record already exists, raise an error.
+        def []=(key, value)
+          raise InvalidEntryClass, "Only entries with class #{target_class} can be added" unless value.is_a?(target_class)
+          identifier = to_identifier(key)
+          raise DuplciateItem, "#{identifier} already present in dictionary." if key?(identifier)
+          super(identifier, value)
+        end
+
+        def [](key)
+          super(to_identifier(key))
+        end
+
+        private
+
+        # Private: Cast an identifier or other object into an identifier.
+        def to_identifier(identifier)
+          case identifier
+          when String, Symbol   then identifier.to_sym
+          when Util::Identifier then identifier.send(identifier_method) # if module is included
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/version.rb

@@ -0,0 +1,3 @@
+module DeadSimpleCMS
+  VERSION = "0.9.0"
+end

data/spec/dead_simple_cms/attribute/collection_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe DeadSimpleCMS::Attribute::Collection do
+
+  subject { described_class.new(:collection_identifier) }
+
+  describe ".dictionary_identifier_method" do
+    it "should default to :identifier" do
+      described_class.dictionary_identifier_method.should == :identifier
+    end
+  end
+
+  its(:identifier) { should == :collection_identifier }
+
+  its(:attributes) { should be_an_instance_of(DeadSimpleCMS::Util::Identifier::Dictionary) }
+
+  its (:persisted?) { should be false }
+
+  describe "#update_attributes" do
+
+    it "should delegate to the setter on #attributes" do
+      subject.should_receive(:foo=).with(:bar)
+      subject.update_attributes(:foo => :bar)
+    end
+
+  end
+
+  describe "#add_attribute" do
+
+    let(:string_attribute) { DeadSimpleCMS::Attribute::Type::String.new(:string_attr) }
+
+    before(:each) { subject.add_attribute(string_attribute) }
+
+    it "should create a getter method" do
+      string_attribute.stub(:value).and_return("value")
+      subject.string_attr.should == "value"
+    end
+
+    it "should create a setter method" do
+      subject.string_attr = "value1"
+      subject.attributes[:string_attr].value.should == "value1"
+    end
+  end
+
+end
+

data/spec/dead_simple_cms/attribute/type/all_spec.rb

@@ -0,0 +1,252 @@
+require "spec_helper"
+
+shared_examples_for DeadSimpleCMS::Attribute::Type::CollectionSupport do
+  describe "#initialize" do
+    context "when collection is provided" do
+
+      let(:options) { {} }
+
+      subject { described_class.new(:some_identifier, options.update(:collection => %w{a b c})) }
+
+      context "and valid :input_type is specified" do
+        let(:options) { {:input_type => :radio} }
+        its(:input_type) { should == :radio }
+      end
+
+      context "and valid :input_type is not specified" do
+        let(:options) { {:input_type => :string} }
+
+        def self.default_input_type(type)
+          around(:each) do |example|
+            tmp = described_class.default_input_type
+            described_class.default_input_type = type
+            example.run
+            described_class.default_input_type = tmp
+          end
+        end
+
+        context "and default_input_type is not valid" do
+          default_input_type(:string)
+          its(:input_type) { should == described_class::DEFAULT_COLLECTION_INPUT_TYPE }
+        end
+
+        context "and default_input_type is valid" do
+          default_input_type(:radio)
+          its(:input_type) { should == :radio }
+        end
+
+      end
+
+    end
+  end
+end
+shared_context "Attribute Setup" do
+
+  let(:options) { {} }
+
+  subject { described_class.new(:sample_identifier, options) }
+
+end
+describe DeadSimpleCMS::Attribute::Type::String do
+
+  include_context "Attribute Setup"
+
+  it_behaves_like DeadSimpleCMS::Attribute::Type::CollectionSupport
+
+  its(:default_input_type) { should == :string }
+
+end
+describe DeadSimpleCMS::Attribute::Type::Text do
+
+  include_context "Attribute Setup"
+
+  its(:default_input_type) { should == :text }
+
+end
+describe DeadSimpleCMS::Attribute::Type::Symbol do
+
+  include_context "Attribute Setup"
+
+  its(:default_input_type) { should == :string }
+
+end
+describe DeadSimpleCMS::Attribute::Type::Boolean do
+
+  include_context "Attribute Setup"
+
+  it_behaves_like DeadSimpleCMS::Attribute::Type::CollectionSupport
+
+  its(:default_input_type) { should == :radio }
+  its(:collection) { should == [true, false] }
+
+  describe "#convert_value" do
+    it %{should convert "true" or "1" into TrueClass} do
+      ["True", "true", "1", "TruE"].each do |str|
+        subject.send(:convert_value, str).should be true
+      end
+    end
+
+    it %{should interpret everything else as false} do
+      %w{abcs false 0 dude sweet}.each do |str|
+        subject.send(:convert_value, str).should be false
+      end
+    end
+
+    context "when a non-String is passed in" do
+      it "should interpret true or false as themselves" do
+        [true, false].each do |bool|
+          subject.send(:convert_value, bool).should be bool
+        end
+      end
+
+      it "should interpret nil as false" do
+        subject.send(:convert_value, nil).should be false
+      end
+
+      it "should interpret other objects" do
+        [Object.new, :dfdf].each { |x| subject.send(:convert_value, x).should be true }
+      end
+
+    end
+  end
+end
+describe DeadSimpleCMS::Attribute::Type::Numeric do
+
+  include_context "Attribute Setup"
+
+  it_behaves_like DeadSimpleCMS::Attribute::Type::CollectionSupport
+
+  its(:default_input_type) { should == :string }
+
+end
+describe DeadSimpleCMS::Attribute::Type::Integer do
+
+  include_context "Attribute Setup"
+
+  it_behaves_like DeadSimpleCMS::Attribute::Type::CollectionSupport
+
+  its(:default_input_type) { should == :string }
+
+  describe "#convert_value" do
+    it "should convert the value into an integer" do
+      subject.send(:convert_value, "545").should be 545
+    end
+
+    it "should return nil if nil passed in" do
+      subject.send(:convert_value, nil).should be nil
+    end
+
+  end
+
+end
+describe DeadSimpleCMS::Attribute::Type::File do
+
+  include_context "Attribute Setup"
+
+  its(:default_input_type) { should == :file }
+
+  let(:file_ext) { "jpg" }
+  let(:data) { double("data") }
+  let(:options) { {:data => data, :file_ext => file_ext}}
+  let(:uploaded_file) do
+    require 'stringio'
+    ActionDispatch::Http::UploadedFile.new(:filename => "filename.png", :tempfile => StringIO.new("file information") )
+  end
+
+  its(:data) { should == data }
+
+  describe "#file_ext" do
+    its(:file_ext) { should == file_ext }
+
+    it "should default to 'dat' if none provided" do
+      described_class.new(:identifier).file_ext.should == "dat"
+    end
+  end
+
+  describe "#convert_value" do
+    it "should return the value if it is a String" do
+      subject.send(:convert_value, "string").should == "string"
+    end
+
+    it "should return the value if it is nil" do
+      subject.send(:convert_value, nil).should be nil
+    end
+
+    context "when ActionDispatch::Http::UploadedFile is passed in" do
+      it "should set the file_ext from the uploaded filename" do
+        subject.send(:convert_value, uploaded_file)
+        subject.file_ext.should == "png"
+      end
+
+      it "should set the data" do
+        subject.send(:convert_value, uploaded_file)
+        subject.data.should == "file information"
+      end
+
+      it "should return the stored @value" do
+        subject.instance_variable_set(:@value, :value)
+        subject.send(:convert_value, uploaded_file).should == :value
+      end
+    end
+  end
+
+  describe "#upload!" do
+
+    context "when uploader_class is not set" do
+      around(:each) do |example|
+        tmp = described_class.uploader_class
+        described_class.uploader_class = nil
+        example.run
+        described_class.uploader_class = tmp
+      end
+
+      it "should raise an error if the uploader_class is not set" do
+        lambda { subject.upload! }.should raise_error(NotImplementedError)
+      end
+
+    end
+
+    context "when uploader_class is set" do
+      let(:file_uploader_class) do
+        Class.new(DeadSimpleCMS::FileUploader::Base) do
+          def upload! ; end
+          def url; "new url" end
+        end
+      end
+
+      before(:each) do
+        subject.uploader_class = file_uploader_class
+      end
+      it "should call upload!" do
+        subject.should_receive(:upload!).once
+        subject.upload!
+      end
+
+      it "should set the url with the value" do
+        subject.upload!
+        subject.value.should == "new url"
+      end
+
+    end
+  end
+
+end
+
+describe DeadSimpleCMS::Attribute::Type::Image do
+
+  include_context "Attribute Setup"
+
+  let(:options) { {:width => 406, :height => 600} }
+
+  its(:width) { should == 406 }
+  its(:height) { should == 600 }
+
+  describe "#hint" do
+    context "when not set" do
+      its(:hint) { should == "Image should be 406 x 600." }
+    end
+  end
+
+end
+
+