brick_layer 0.9.0

data/app/helpers/brick_layer/layout_helper.rb

@@ -0,0 +1,20 @@
+module BrickLayer::LayoutHelper
+  def standalone_navigation    
+    html = ''
+    BrickLayer.data_sets_standalones.each do |klass_in_symbol_form|
+      klass_to_model_param = klass_in_symbol_form.to_s.underscore.pluralize      
+      html += content_tag :li do
+        content_tag(:a, klass_in_symbol_form.to_s.underscore.titlecase, :href => data_sets_path(:model => klass_to_model_param))
+      end
+    end
+    
+    content_tag( :ul, content_tag(:li, "Standalone Content") + html.html_safe )
+  end
+  
+  def nested_routes(routes)
+    routes.map do |route, sub_routes|
+      render(route) + content_tag(:ul, nested_routes(sub_routes), :class => "sub_routes")
+    end.join.html_safe
+  end
+
+end

data/app/helpers/brick_layer/site_helper.rb

@@ -0,0 +1,5 @@
+module BrickLayer::SiteHelper
+  def collection_of_data_sets
+    PageDataSets.local_constant_names.map { |set| [set.to_s.underscore.titlecase, set] }
+  end
+end

data/app/models/brick_layer/data_set.rb

@@ -0,0 +1,219 @@
+class BrickLayer::DataSet
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  field :title,             type: String
+  field :meta_description,  type: String
+  field :meta_keywords,     type: String
+  field :route_id,          type: Integer
+
+  belongs_to :route,        :class_name => "BrickLayer::Route"
+  
+  # Expose set methods based on data set, this also gives you the ability to pull from fields that an object has set.
+  # This allows the methods to return the results with the method as the key in a hash to json conversion.
+  #
+  # Example: 
+  #   expose_data :method_1, :method_2
+  #
+  #   def method_1
+  #     list_of_results = result_1, result_2, result_3
+  #   end
+  #
+  def self.expose_data(*field_array)
+    class << self
+      attr_accessor :collect_exposed_data_methods
+    end
+    
+    @collect_exposed_data_methods = @collect_exposed_data_methods.blank? ? field_array : (@collect_exposed_data_methods + field_array)
+    define_method :exposed_data_methods do; self.class.collect_exposed_data_methods; end
+  end
+    
+  # Override as_json to return proper exposed data methods
+  def as_json(options={})
+    original_attributes = super(options)
+    complete_attributes = {}
+    
+    # This takes a generic data sets and preps it for to json conversion
+    unless self.route.blank?
+      obj = self.route_custom_template_class.new(self.attributes)
+    else
+      obj = self
+    end
+
+    if obj.respond_to?("exposed_data_methods")
+      obj.exposed_data_methods.each { |vfield| complete_attributes[vfield] = obj.send(vfield) }
+    end
+
+    complete_attributes.merge(original_attributes)
+  end
+  
+  ### INTROSPECTION ###
+  
+  # Display all fields in arry for the class
+  def self.all_fields(options={})
+    if options[:added_only]
+      results = self.fields.keys - BrickLayer::DataSet.fields.keys 
+    else
+      results = self.fields.keys
+    end
+    
+    results += options[:add_fields].map(&:to_s) if options[:add_fields]    
+    options[:ignore_fields].each { |f| results.delete(f) } if options[:ignore_fields]
+    
+    return results
+  end
+  
+  # Display all exposed data methods in an array for the class
+  def self.exposed_data_methods
+    begin
+      return self.new.exposed_data_methods.map(&:to_s).uniq
+    rescue NoMethodError
+      []
+    end
+  end
+  
+  # Display both fields and exposed data methods for the class
+  def self.all_fields_and_exposed_data_methods
+    (all_fields + exposed_data_methods).uniq
+  end
+  
+  # Grab the custom class if this class has a route
+  def route_custom_template_class
+    "PageDataSets::#{self.route.data_set_template}".constantize unless self.route.try(:data_set_template).blank?
+  end
+  
+  ############################
+  
+  
+  ### CUSTOM FIELD SUPPORT ###
+  class << self; attr_accessor :custom_fields, :custom_field_options; end      
+  
+  # This allows a user to create a custom field that will be recognized as a field type for other uses in the application
+  # like the UI
+  def self.custom_field(field_name, field_type, options={})
+    @custom_fields ||= {}
+    @custom_field_options ||= {}
+    
+    if field_type == :image
+      @custom_fields[field_name.to_sym] = :file
+      
+      field "#{field_name}_uid",  type: String
+      field "#{field_name}_name", type: String
+      
+      image_accessor field_name
+      
+      # grab the sizes and expose it if sizes are set
+      if !options[:sizes].blank?
+        options[:sizes].each do |size_name, value|
+          expose_data "#{field_name}_#{size_name}".to_sym
+          
+          define_method "#{field_name}_#{size_name}".to_sym do
+            self.send(field_name.to_s).try(:thumb, value).try(:url)
+          end
+        end
+      else
+        @custom_fields[field_name.to_sym] = field_type
+        field field_name, type: String
+      end
+    
+    elsif field_type == :file
+      @custom_fields[field_name.to_sym] = field_type
+      field field_name, type: String
+      
+      mount_uploader field_name.to_sym, BrickLayer::FileUploader, :mount_on => "#{field_name}_filename".to_sym
+    else
+      @custom_field_options[field_name.to_sym] = options unless options.blank?
+      @custom_fields[field_name.to_sym] = field_type
+      field field_name, type: String
+    end
+  end
+  
+  # convert an array of ids to an array of objects
+  def translate_string_ids_to_objects(array_of_ids)
+    unless array_of_ids.blank?
+      return BrickLayer::DataSet.find(array_of_ids) if array_of_ids.is_a?(String)
+    
+      return array_of_ids.map do |x|
+        begin
+          BrickLayer::DataSet.find(x)
+        rescue
+          x
+        end
+      end
+    end
+  end
+  
+  # convert an id string to an object
+  def translate_obj_to_string(string_id)
+    begin
+      BrickLayer::DataSet.find(string_id)
+    rescue
+      string_id
+    end
+  end
+    
+  # overriding #update_attributes to support the passing of object ids as an array of strings (works better for forms)
+  def update_attributes(update_hash)
+    update_hash.each do |k,v|
+      if self.relations.keys.include?(k.to_s)
+        self.send("#{k}=", translate_string_ids_to_objects(v)) if relations[k].macro == :referenced_in
+        self.send("#{k}=", translate_obj_to_string(v))         if relations[k].macro == :references_one
+        self.send("#{k}=", translate_string_ids_to_objects(v)) if relations[k].macro == :references_and_referenced_in_many || relations[k].macro == :references_many
+      else
+        self.send("#{k}=",v)
+      end
+    end
+
+    return self.save
+  end
+  
+  ############################
+  
+  
+  ### SEARCH FUNCTIONALITY ###
+  # using mongoid_fulltext - go to https://github.com/aaw/mongoid_fulltext for more details
+  
+  include Mongoid::FullTextSearch
+  
+  def self.fulltext_search_in(*args)
+    search_in_hash = args.find { |x| x.is_a?(Hash) }
+        
+    # Inject a type index filter (this allows easy support for STI full search scoping)
+    if search_in_hash
+      unless search_in_hash[:filters].blank?
+        new_hash = search_in_hash[:filters].merge({ :type_index => lambda { |x| x._type } })
+      else
+        new_hash = search_in_hash.merge({:filters => { :type_index => lambda { |x| x._type } }})
+      end
+    end
+    
+    args.delete(search_in_hash) if args.include?(search_in_hash)
+    
+    args << (new_hash || {:filters => { :type_index => lambda { |x| x._type } }})
+    super
+  end
+      
+  # Override fulltext search to support inheritence
+  def self.fulltext_search(query_string,options={})
+    options.merge!({:type_index => self.name}) unless self.superclass == Object
+    super(query_string,options)
+  end
+  
+  # Full Text Search Defaults
+  fulltext_search_in :title, :meta_description, :meta_keywords
+  
+  ############################
+  
+  def method_missing(*args)
+    # Catch Un-initiated Attributes
+    begin
+      super(*args)
+    rescue NoMethodError => e
+      if !self.route_custom_template_class.blank?
+        raise e unless self.route_custom_template_class.all_fields.include?(e.name.to_s)
+      else
+        Rails.logger.error("ERROR (NO METHOD): #{e}")
+      end
+    end
+  end
+end

data/app/models/brick_layer/file_uploader.rb

@@ -0,0 +1,7 @@
+class BrickLayer::FileUploader < CarrierWave::Uploader::Base
+  storage :grid_fs
+    
+  def cache_dir
+    "#{Rails.root}/tmp/uploaded_files"
+  end
+end

data/app/models/brick_layer/route.rb

@@ -0,0 +1,68 @@
+class BrickLayer::Route
+  include Mongoid::Document
+  include Mongoid::Ancestry
+  has_ancestry
+  
+  field :current_parent_id, type: String
+  field :slug,              type: String
+  field :data_set_template, type: String
+  field :full_path_cache,   type: String
+  
+  has_one :data_set, class_name: "BrickLayer::DataSet", autosave: true
+  accepts_nested_attributes_for :data_set, :allow_destroy => true
+  
+  validates :slug, :uniqueness => { :scope => :current_parent_id }
+  
+  before_validation :set_parent
+  before_save       :set_full_path_cache
+  after_save        :update_routes
+  
+  # Grab or create root
+  def self.root    
+    root_exist = BrickLayer::Route.where(:slug => "").count > 0
+    
+    if root_exist      
+      return BrickLayer::Route.where(:slug => "").first
+    else
+      return BrickLayer::Route.create(:slug => "")
+    end
+  end
+  
+  # Display the full path for a route
+  def full_path
+    self.ancestors.sort_by { |x| x.ancestry.to_s }.map { |x| x.slug }.join("/") + "/#{self.slug}"
+  end
+  
+  # For parent purposes
+  def to_s
+    slug.blank? ? "home (root)" : slug
+  end
+    
+  # Use this method to keep up with hiearchry for #full_path
+  def set_parent
+    unless parent_id.blank?
+      self.current_parent_id = parent_id.to_s
+    end
+  end
+  
+  # Set the full path cache for easy lookup
+  def set_full_path_cache
+    unless self.slug.blank?
+      self.full_path_cache = self.full_path
+    else
+      self.full_path_cache = ""
+    end
+  end
+  
+  # Change parent 
+  def change_parent_to(parent_route)
+    self.parent_id = parent_route.id
+  end
+  
+  # Update Children Routes
+  def update_routes
+    unless self.children.blank?
+      self.children.each { |r| r.save }
+    end
+  end
+end

data/app/models/brick_layer/search.rb

@@ -0,0 +1,61 @@
+class BrickLayer::Search
+  MAPPINGS = {
+    :use_array    => ["all","in","nin","near"],
+    :use_boolean  => ["exists"],
+    :use_integer  => ["gt","gte","lt","lte","size"]
+  }
+  
+  class << self
+    # Actually perform the search with a set of params and options on an object
+    def perform_search(params,options={})
+      class_to_use = params[:model].blank? ? BrickLayer::DataSet : params[:model].gsub('"','').singularize.camelize.constantize
+      
+      if params[:q]
+        fulltext_options = options[:ft_options].blank? ? {} : options[:ft_options]
+        results = class_to_use.fulltext_search(params[:q],fulltext_options)
+      elsif params[:queries]
+        params[:queries].each do |param_set|
+          query = params_to_query({param_set[0] => param_set[1]})
+          query_set = results || class_to_use
+          
+          results = query_set.where(query)
+        end
+      else
+        query = params_to_query(params)
+        results = query.blank? ? [] : class_to_use.where(query)
+      end
+      
+      return results
+    end
+    
+    # Convert the passed in params to a mongoid compatible search query
+    def params_to_query(params_hash)
+      [:controller, :action, :format, :model].each { |a| params_hash.delete(a) }
+      query_params = {}
+      params_hash.each do |k,v|
+        break_up_params = k.to_s.split("_")
+        operator  = break_up_params.delete_at(-1)
+        attribute = break_up_params.join("_")
+        query_params[attribute.to_sym.send(operator)] = value_wrapper( operator, (v.respond_to?("gsub") ? v.gsub('"','') : v) )
+      end
+      
+      return query_params
+    end
+    
+    
+    private
+    
+    # Wrap the compatiable values for the mongo search
+    def value_wrapper(operator, value)
+      if MAPPINGS[:use_array].include?(operator)
+        return eval(value) if value.include?("[") && value.include?("]")
+        return value if value.is_a?(Array)
+        return [value]
+      end
+      
+      return eval(value) if MAPPINGS[:use_boolean].include?(operator)
+      return value.to_i  if MAPPINGS[:use_integer].include?(operator)
+      return value
+    end
+  end
+end

data/app/views/brick_layer/data_sets/_form.html.haml

@@ -0,0 +1,18 @@
+- attributes_for(@model_constant, :added_only => true).each do |attribute|    
+  = form_field_formatter(f, attribute)
+  - if f.object.send(attribute).respond_to?("image?") && !f.object.send("#{attribute}_uid").blank?
+    %p
+      = image_tag(f.object.send(attribute).thumb('100x100#').url)
+      = f.check_box("remove_#{attribute}")
+      = f.label "Remove #{attribute.titlecase}"
+    
+  - if f.object.send(attribute).to_s.try(:include?, "/files/")
+    %p
+      = link_to "Current #{attribute} File", f.object.send(attribute).to_s
+      = f.check_box("remove_#{attribute}")
+      = f.label "Remove #{attribute.titlecase}"
+
+- relations_for(@model_constant, :ignore => ["route"]).each do |relation|
+  .input.relation
+    %label= relation.titlecase
+    = relation_field_formatter(f, relation)

data/app/views/brick_layer/data_sets/edit.html.haml

@@ -0,0 +1,7 @@
+%h1== Edit  #{@model_constant.to_s.titlecase} '#{@data_set.to_s}'
+
+= simple_form_for @model_constant.find(@data_set.id), :as => :data_set, :url => data_set_path(:model => params[:model], :id => @data_set.id), :multipart => true, :method => :put do |f|
+  = render :partial => "form", :locals => { :f => f }
+  = f.button :submit, "Update"
+   | 
+  = link_to "Cancel", :back

data/app/views/brick_layer/data_sets/index.html.haml

@@ -0,0 +1,25 @@
+%h1= params[:model].titlecase
+%p= link_to "Add More Data", new_data_set_path(:model => params[:model])
+
+- if !@data_sets.blank?
+  %table
+    %thead
+      %tr
+        - attributes_for(@model_constant, :ignore_image_fields => true).each do |attribute|
+          %th= attribute.to_s.gsub("_","").titlecase
+        %th Actions
+      
+    %tbody
+      - @data_sets.each do |data_set|
+        %tr
+          - attributes_for(@model_constant, :ignore_image_fields => true).each do |a| 
+            %td= pretty_format_type(data_set.send(a))
+          %td
+            = link_to "View", data_set_path(:model => params[:model], :id => data_set.id)
+             | 
+            = link_to "Edit", edit_data_set_path(:model => params[:model], :id => data_set.id)
+- else
+  %p== Currently there are not any #{@model_constant.name.pluralize.titlecase} in the system 
+  
+- content_for :subnavigation do
+  = render :partial => "brick_layer/shared/custom_data_sets_list"

data/app/views/brick_layer/data_sets/new.html.haml

@@ -0,0 +1,5 @@
+%h1== New #{@model_constant.to_s.titlecase} Object
+
+= simple_form_for @model_constant.new, :as => :data_set, :url => data_sets_path(:model => params[:model]), :multipart => true do |f|
+  = render :partial => "form", :locals => { :f => f }
+  = f.button :submit, "Create"

data/app/views/brick_layer/data_sets/search.html.haml

@@ -0,0 +1 @@
+%h1== Search Results for #{params[:model].blank? ? 'All' : params[:model] } Documents

data/app/views/brick_layer/data_sets/show.html.haml

@@ -0,0 +1,32 @@
+%h1== #{params[:model].titlecase.singularize} - #{@data_set.to_s}
+%p
+  = link_to "Edit", edit_data_set_path(@data_set, :model => params[:model])
+   | 
+  = link_to "Back to #{params[:model].titlecase.pluralize}", data_sets_path(:model => params[:model])
+
+- unless attributes_for(@model_constant, :added_only => true).blank?
+  %dl
+    - attributes_for(@model_constant, :added_only => true).each do |attribute|
+      %dt== #{attribute.titlecase}:
+      - if @data_set.send(attribute).respond_to?("image?")
+        = image_tag(@data_set.send(attribute).thumb('100x100#').url)
+      - elsif @data_set.send(attribute).to_s.try(:include?,"/files/")
+        - uploaded_file = @data_set.send(attribute)
+        = link_to (uploaded_file.model.send("#{attribute}_filename") || uploaded_file.to_s), uploaded_file.url, :target => "_blank"
+        %br
+      - else
+        %dd= @data_set.send(attribute)
+      
+      %br
+    
+    - relations_for(@model_constant, :ignore => ["route"]).each do |relation|
+      %dt== #{relation.titlecase}:
+      %dd
+        - if @data_set.send(relation).is_a?(Array)
+          - @data_set.send(relation).each do |res|
+            = res.to_s.blank? ? "Nothing" : res.to_s
+            = ", " unless res == @data_set.send(relation).last
+            
+        - else
+          = @data_set.send(relation).to_s.blank? ? "Nothing" : @data_set.send(relation).to_s
+      %br

data/app/views/brick_layer/layouts/brick_layer_layout.html.haml

@@ -0,0 +1,40 @@
+!!! 5
+%head
+  %title Site Manager
+  = stylesheet_link_tag "application"
+  = javascript_include_tag "tiny_mce/tiny_mce"
+  = csrf_meta_tags
+
+%body#brick-layer
+  %nav
+    %ul
+      - if BrickLayer.enable_pages
+        %li= link_to "Pages", routes_path
+      
+      - unless BrickLayer.data_sets_standalones.blank?
+        %li= link_to "Custom Data Sets", list_data_sets_path
+
+  %br.clear
+  - if yield(:subnavigation).blank? || BrickLayer.data_sets_standalones.blank?
+    #content= yield
+  - else
+    #content        
+      #sub-navigation
+        = yield :subnavigation
+      #primary-content
+        = yield
+  
+  %script(src="/javascripts/tiny_mce/tiny_mce.js" type="text/javascript")
+  %script(type="text/javascript")
+    :plain
+      tinyMCE.init({
+        mode : "textareas",
+        plugins: "inlinepopups",
+        editor_selector : "withEditor",
+        theme_advanced_toolbar_location: "top",
+        theme_advanced_toolbar_align : "left",
+        theme : "advanced",
+        theme_advanced_buttons1: "justifyleft,justifycenter,justifyright,|,bold,italic,underline,strikethrough,|,bullist,numlist,|,formatselect,|,code",
+        theme_advanced_buttons2: "",
+        theme_advanced_buttons3: ""
+      });

data/app/views/brick_layer/manager/data_set_list.html.haml

@@ -0,0 +1 @@
+= render :partial => "brick_layer/shared/custom_data_sets_list"

data/app/views/brick_layer/manager/index.html.haml

@@ -0,0 +1 @@
+%h1 Welcome to Brick Layer!

data/app/views/brick_layer/routes/_form.html.haml

@@ -0,0 +1,11 @@
+- parent_route = @route.parent || BrickLayer::Route.root
+
+- unless @route == BrickLayer::Route.root
+  .related-inputs
+    %input(type="hidden" name="parent" value="#{parent_route.id}")
+    = parent_route.full_path
+    = "/" unless parent_route.slug == ""
+
+    = f.input :slug, :label => false, :placeholder => "Slug"
+
+%p= f.input :data_set_template, :collection => collection_of_data_sets, :as => :select, :label => "Data Set Template", :prompt => "--- Choose a Template ---"

data/app/views/brick_layer/routes/_route.html.haml

@@ -0,0 +1,15 @@
+%li
+  = route.to_s
+  %small
+    (
+    - if route == BrickLayer::Route.root
+      = link_to "view page", "/brick_layer/pages", :target => "_blank"
+    - else
+      = link_to "view page", "/brick_layer/pages#{route.full_path}", :target => "_blank"
+      
+     | 
+    = link_to "edit", edit_route_path(route)
+    - unless route.slug == ""
+       | 
+      = link_to "add", new_route_path(route, :parent => route.id)
+    )

data/app/views/brick_layer/routes/edit.html.haml

@@ -0,0 +1,21 @@
+%h1== Editing '#{@route.to_s}' Page
+
+= simple_form_for @route, :url => route_path(@route) do |f|
+  = render :partial => "form", :locals => { :f => f }
+  
+  %p= f.input :parent_id, :collection => @routes, :as => :select, :label => "Parent Route", :prompt => "--- Choose Route ---"
+  
+  - unless @data_set_template.to_s.blank?
+    = f.simple_fields_for :data_set, @data_set_obj do |ff|
+      - attributes_for(@data_set_template).each do |attribute|
+        = form_field_formatter(ff, attribute)
+    
+      - relations_for(@data_set_template, :ignore => ["route"]).each do |relation|
+        .input.relation
+          %label= relation.titlecase          
+          = relation_field_formatter(f, relation)
+  
+  %p
+    = f.submit "Update Page"
+     | 
+    = link_to "Delete Route", route_path(@route), :method => :delete, :confirm => "You sure you want to remove this route?"

data/app/views/brick_layer/routes/index.html.haml

@@ -0,0 +1,5 @@
+%h1 Pages
+%p= link_to "New Route", new_route_path
+
+#routes
+  = nested_routes(BrickLayer::Route.root.subtree.arrange(:order => [:slug, :asc]))

data/app/views/brick_layer/routes/new.html.haml

@@ -0,0 +1,5 @@
+%h1 New Page
+
+= simple_form_for @route, :url => routes_path do |f|
+  = render :partial => "form", :locals => { :f => f }
+  %p= f.submit "Create Page"

data/app/views/brick_layer/routes/show.html.haml

@@ -0,0 +1,27 @@
+%h1== '#{@route.to_s}' Page
+
+- unless attributes_for(@model_constant, :added_only => true).blank?
+  %dl
+    - attributes_for(@model_constant, :added_only => true).each do |attribute|
+      - if @data_set.respond_to?(attribute)      
+        %dt== #{attribute.titlecase}:
+        %dd= @data_set.send(attribute)
+        %br
+    
+    - relations_for(@model_constant, :ignore => ["route"]).each do |relation|
+      %dt== #{relation.titlecase}:
+      %dd
+        - if @data_set.send(relation).is_a?(Array)
+          - @data_set.send(relation).each do |res|
+            = res.to_s.blank? ? "Nothing" : res.to_s
+            = ", " unless res == @data_set.send(relation).last
+            
+        - else
+          = @data_set.send(relation).to_s.blank? ? "Nothing" : @data_set.send(relation).to_s
+      %br
+
+    - if @model_constant.respond_to?("exposed_data_methods")
+      - @model_constant.exposed_data_methods.each do |vfield|
+        - if @data_set.respond_to?(vfield)
+          %dt== #{vfield.titlecase}:
+          %dd= @data_set.send(vfield,{:html => true})

data/app/views/brick_layer/shared/_custom_data_sets_list.html.haml

@@ -0,0 +1,9 @@
+%h1 List of Data Sets
+
+- unless BrickLayer.data_sets_standalones.blank?
+  %ul
+    - BrickLayer.data_sets_standalones.sort.each do |set|
+      %li= link_to set.to_s.underscore.pluralize.titlecase, data_sets_path(:model => set.to_s.pluralize)
+      %br
+- else
+  %p Currently no data sets are set in the config file.

data/config/initializers/brick_layer_carrierwave.rb

@@ -0,0 +1,6 @@
+CarrierWave.configure do |config|
+  config.grid_fs_database = Mongoid.database.name
+  config.grid_fs_host     = Mongoid.config.master.connection.host
+  config.storage          = :grid_fs
+  config.grid_fs_access_url = "/files"
+end

data/config/initializers/brick_layer_dragonfly.rb

@@ -0,0 +1,10 @@
+require 'dragonfly/rails/images'
+
+app = Dragonfly[:images]
+app.configure_with(:imagemagick)
+
+app.configure_with(:rails) do |c|
+  c.datastore = Dragonfly::DataStorage::MongoDataStore.new :db => Mongoid.database
+end
+
+app.define_macro_on_include(Mongoid::Document, :image_accessor)