dead_simple_cms 0.9.0

data/lib/dead_simple_cms/attribute/collection.rb

@@ -0,0 +1,45 @@
+module DeadSimpleCMS
+  module Attribute
+    class Collection
+      include Util::Identifier
+
+      attr_reader :attributes
+
+      delegate :[], :[]=, :to => :attributes
+
+      # The method used to construct the identifier (key) by which the attribute (value) will be stored with.
+      class_attribute :dictionary_identifier_method
+      self.dictionary_identifier_method = :identifier
+
+      def initialize(identifier, options={})
+        @attributes = Attribute::Type::Base.new_dictionary(:identifier_method => dictionary_identifier_method)
+        super
+      end
+
+      # Play nicely with Rails fields_for.
+      def persisted?
+        false
+      end
+
+      def update_attributes(attributes)
+        attributes.each { |k, v| send("#{k}=", v) }
+      end
+
+      def add_attribute(attribute)
+        attributes.add(attribute)
+        attribute_accessor(attribute)
+      end
+
+      private
+
+      def attribute_accessor(attribute)
+        identifier = attribute.send(dictionary_identifier_method)
+        instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{identifier}     ; attributes[#{identifier.inspect}].value     ; end
+          def #{identifier}=(v) ; attributes[#{identifier.inspect}].value = v ; end
+        RUBY
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/attribute/type/all.rb

@@ -0,0 +1,104 @@
+module DeadSimpleCMS
+  module Attribute
+    module Type
+      class String < Base
+        self.default_input_type = :string
+        include CollectionSupport
+      end
+      class Text < String
+        self.default_input_type = :text
+      end
+      class Symbol < Base
+        self.default_input_type = :string
+        def convert_value(value)
+          value.to_s.to_sym if value.present?
+        end
+        private :convert_value
+      end
+      class Boolean < Base
+        self.default_input_type = :radio
+
+        include CollectionSupport
+
+        def initialize(identifier, options={})
+          options.update(:collection => [true, false], :default => false)
+          super
+        end
+
+        private
+
+        def convert_value(value)
+          value.is_a?(::String) ? ["true", "1"].include?(value.downcase) : !!value
+        end
+
+      end
+      class Numeric < Base
+        self.default_input_type = :string
+        include CollectionSupport
+      end
+      class Integer < Numeric
+        def convert_value(value)
+          value && value.to_i
+        end
+      end
+      # Public: File attributes are stored at some publicly accessible url.
+      class File < Base
+        self.default_input_type = :file
+
+        attr_accessor :data, :file_ext
+
+        class_attribute :uploader_class
+
+        alias :url :value
+
+        def initialize(identifier, options={})
+          @data     = options[:data]
+          @file_ext = options[:file_ext] || "dat"
+          super
+        end
+
+        # Public: Takes the current #value, detects if its an object to upload and replaces the #value with the url
+        # to be stored in the CMS.
+        def upload!
+          raise NotImplementedError, "Please define an uploader class (see DeadSimpleCMS::FileUploader::Base)" unless uploader_class
+          return unless data
+
+          s3_uploader = uploader_class.new(self)
+          s3_uploader.upload!
+          self.value = s3_uploader.url
+        end
+
+        private
+
+        def convert_value(value)
+          case value
+          when ::String, NilClass
+            value
+          when ActionDispatch::Http::UploadedFile
+            @file_ext = value.original_filename[/\.(.+)$/, 1]
+            value.rewind # make sure it's rewound
+            self.data = value.read
+            @value # just return the same stored @value so it doesn't change for now
+          else
+            raise("Don't know how to convert value: #{value.inspect}")
+          end
+        end
+
+      end
+      class Image < File
+
+        attr_reader :width, :height
+
+        def initialize(identifier, options={})
+          @width, @height = options.values_at(:width, :height)
+          super
+        end
+
+        def hint
+          super || "Image should be #{width} x #{height}."
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/attribute/type/base.rb

@@ -0,0 +1,79 @@
+module DeadSimpleCMS
+  module Attribute
+    module Type
+      class Base
+
+        include Util::Identifier
+
+        class << self
+          # Public: the method name used to identify this type in the Builder
+          attr_writer :builder_method_name
+
+          # If not provided on the subclass infer it from the class name. Because of how class_attribute works, this
+          # method will be overwritten when someone explicitly calls .builder_method_name= on a subclass.
+          def builder_method_name
+            @builder_method_name ||=  name.demodulize.underscore
+          end
+
+        end
+
+        # Public: a Symbol representing the default input type required for forms
+        class_attribute :default_input_type, :instance_writer => false
+
+        VALID_INPUT_TYPES = [:string, :text, :select, :file, :radio].freeze
+
+
+        attr_reader   :hint, :input_type, :group_hierarchy, :required
+        attr_accessor :section
+
+        def initialize(identifier, options={})
+          options.reverse_merge!(:group_hierarchy => [], :input_type => default_input_type, :required => false)
+          @hint, @default, @input_type, @group_hierarchy, @section, @required =
+            options.values_at(:hint, :default, :input_type, :group_hierarchy, :section, :required)
+          raise("Invalid input type: #{input_type.inspect}. Should be one of #{VALID_INPUT_TYPES}.") unless VALID_INPUT_TYPES.include?(input_type)
+          super
+        end
+
+        def root_group?
+          group_hierarchy.last.try(:root?)
+        end
+
+        # Public: The identifier on the section level. It must be unique amongst the groups.
+        def section_identifier
+          (group_hierarchy + [self]).map(&:identifier).join("_").to_sym
+        end
+
+        def default
+          @default.is_a?(Proc) ? @default.call : @default
+        end
+
+        def value=(value)
+          @value = convert_value(value)
+        end
+
+        # Public: Returns the non-blank value from the storage or the default.
+        def value
+          return @value if instance_variable_defined?(:@value) # If the value was set to nil, we should return that value.
+          attributes = attributes_from_storage
+          @value = attributes.key?(section_identifier) ? attributes[section_identifier] : default
+        end
+
+        def inspect
+          ivars = [:identifier, :hint, :default, :required, :input_type].map { |m| ivar = "@#{m}" ; "#{ivar}=#{instance_variable_get(ivar).inspect}" }
+          "#<#{self.class} #{ivars.join(", ")}"
+        end
+
+        private
+
+        def attributes_from_storage
+          section.storage.read
+        end
+
+        def convert_value(value)
+          value.presence
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/attribute/type/collection_support.rb

@@ -0,0 +1,26 @@
+module DeadSimpleCMS
+  module Attribute
+    module Type
+      module CollectionSupport
+
+        VALID_COLLECTION_INPUT_TYPES = [:select, :radio].freeze
+
+        DEFAULT_COLLECTION_INPUT_TYPE = :select
+
+        def initialize(identifier, options={})
+          if @collection = options[:collection]
+            # Pick either the options[:input_type], default_input_type, or the :select. Whichever matches the valid types.
+            options[:input_type] = ([options[:input_type], default_input_type, DEFAULT_COLLECTION_INPUT_TYPE] & VALID_COLLECTION_INPUT_TYPES).first
+          end
+          super
+        end
+
+        # Public: For performance and loading reasons, we allow the ability to pass through a collection as a lambda.
+        def collection
+          @collection.is_a?(Proc) ? @collection.call : @collection
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/configuration.rb

@@ -0,0 +1,50 @@
+module DeadSimpleCMS
+  class Configuration
+
+    def section(identifier, options={}, &block)
+      section = DeadSimpleCMS::Section.new(identifier, options, &block)
+      DeadSimpleCMS.sections.add(section)
+      # Convenience method, allows one to access DeadSimpleCMS.sections.<section_name>
+      DeadSimpleCMS.sections.instance_eval %{def #{section.identifier} ; self[#{section.identifier.inspect}] ; end}
+    end
+
+    def group_configuration(identifier, options={}, &block)
+      DeadSimpleCMS.group_configurations.add(Group::Configuration.new(identifier, options, &block))
+    end
+
+    def register_attribute_classes(*classes)
+      classes.each do |klass|
+        DeadSimpleCMS::Section::Builder.define_attribute_builder_method(klass)
+        Group::Configuration.define_attribute_builder_method(klass)
+      end
+    end
+
+    def storage_class(klass=nil, options={})
+      if klass
+        klass = "DeadSimpleCMS::Storage::#{klass.to_s.classify}".constantize if klass.is_a?(Symbol)
+        options.each { |k, v| klass.send("#{k}=", v) }
+        Section.storage_class = klass
+      end
+      Section.storage_class
+    end
+
+    def storage_serializer_class(klass=nil)
+      Storage::Base.serializer_class = klass if klass
+      Storage::Base.serializer_class
+    end
+
+    def default_form_builder(klass=nil)
+      if klass
+        klass = "DeadSimpleCMS::Rails::ActionView::FormBuilders::#{klass.to_s.classify}".constantize if klass.is_a?(Symbol)
+        DeadSimpleCMS::Rails::ActionView::Presenter.form_builder = klass
+      end
+      DeadSimpleCMS::Rails::ActionView::Presenter.form_builder
+    end
+
+    def file_uploader_class(klass=nil)
+      Attribute::Type::File.uploader_class = klass if klass
+      Attribute::Type::File.uploader_class
+    end
+
+  end
+end

data/lib/dead_simple_cms/file_uploader/base.rb

@@ -0,0 +1,29 @@
+module DeadSimpleCMS
+  module FileUploader
+    # Base file uploader class. Inherit from this to build your own uploaders for files.
+    class Base
+
+      attr_reader :file_attribute
+      delegate :file_ext, :data, :to => :file_attribute
+
+      def initialize(file_attribute)
+        @file_attribute = file_attribute
+      end
+
+      def upload!
+        raise NotImplementedError, "Please overwrite this with your own upload functionality."
+      end
+
+      def url
+        raise NotImplementedError, "Please overwrite this with your own url constructor."
+      end
+
+      # Public: We need to have all these nesting to protect against corner-case collisons.
+      def path(namespace="dead_simple_cms")
+        # dead_simple_cms/<section>/<group>/attribute.jpg
+        @path ||= [namespace, *[file_attribute.section, *file_attribute.group_hierarchy, file_attribute].map(&:identifier)].compact * "/" + "." + file_ext
+      end
+
+    end
+  end
+end

data/lib/dead_simple_cms/group.rb

@@ -0,0 +1,58 @@
+module DeadSimpleCMS
+  # Public: A Group is essentially an Attribute::Collection with the ability to have it's own groups on it with infinite
+  # nesting of groups.
+  class Group < Attribute::Collection
+
+    ROOT_IDENTIFIER = :root
+
+    attr_reader :groups, :presenter_class, :render_proc
+
+    def initialize(identifier, options={})
+      @groups = DeadSimpleCMS::Group.new_dictionary
+      super
+    end
+
+    def self.root
+      new(ROOT_IDENTIFIER)
+    end
+
+    # Public: Set different mechanisms for rendering this group.
+    def display(presenter_class=nil, &block)
+      @presenter_class = presenter_class
+      @render_proc = block
+    end
+
+    # Public: If a presenter class was specified, returns an instance of the presenter.
+    def presenter(view_context, *args)
+      @presenter_class.new(view_context, *args) if @presenter_class
+    end
+
+    # Public: Render the group using the passed in proc in the scope of the template.
+    def render(view_context, *args)
+      if @render_proc
+        view_context.instance_exec(self, *args, &@render_proc)
+      elsif presenter = presenter(view_context, self, *args)
+        presenter.render
+      end
+    end
+
+    def root?
+      identifier == ROOT_IDENTIFIER
+    end
+
+    def add_group(group)
+      groups.add(group)
+      group_accessor(group)
+    end
+
+    private
+
+    # The <group>_attributes method plays nice with form builder's fields_for.
+    def group_accessor(group)
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{group.identifier}_attributes=(v) ; groups[#{group.identifier.inspect}].update_attributes(v) ; end
+        def #{group.identifier} ; groups[#{group.identifier.inspect}] ; end
+      RUBY
+    end
+  end
+end

data/lib/dead_simple_cms/group/configuration.rb

@@ -0,0 +1,32 @@
+module DeadSimpleCMS
+  class Group
+    class Configuration
+
+      include Util::Identifier
+
+      attr_reader :options, :attribute_arguments, :presenter_class, :render_proc
+
+      def initialize(identifier, options={}, &block)
+        super(identifier, options)
+        @options = options
+        @attribute_arguments = {}
+        instance_eval(&block)
+      end
+
+      def display(presenter_class=nil, &block)
+        @presenter_class = presenter_class if presenter_class
+        @render_proc = block if block_given?
+      end
+
+      def self.define_attribute_builder_method(klass)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{klass.builder_method_name}(identifier, options={})
+            attribute_arguments[identifier] = [#{klass.builder_method_name.inspect}, options]
+          end
+        RUBY
+      end
+
+    end
+
+  end
+end

data/lib/dead_simple_cms/group/presenter.rb

@@ -0,0 +1,23 @@
+require 'delegate'
+module DeadSimpleCMS
+  class Group
+    # Public: Presenter class used for rendering groups.
+    #
+    # Within the context of this group, you can call methods as if you were in the view_context.
+    class Presenter < SimpleDelegator
+
+      attr_reader :group
+
+      def initialize(view_context, group, *args)
+        @group = group
+        initialize_extra_arguments(*args)
+        super(view_context)
+      end
+
+      # Private: Initialize extra arguments for the presenter.
+      def initialize_extra_arguments(*args)
+      end
+
+    end
+  end
+end