underworld 1.0.0

data/lib/underworld/dashboard.rb

@@ -0,0 +1,11 @@
+#require_dependency 'underworld/dashboard/dsl'
+
+module Underworld::Dashboard
+  autoload :DSL, 'underworld/dashboard/dsl'
+
+  module Helpers
+  end
+
+  autoload :Models,   'underworld/dashboard/models'
+  autoload :Sections, 'underworld/dashboard/sections.rb'
+end

data/lib/underworld/dashboard/dsl.rb

@@ -0,0 +1,41 @@
+require_dependency 'underworld/dashboard/dsl/form_fields_properties'
+require_dependency 'underworld/dashboard/sections/resource'
+require_dependency 'underworld/dashboard/sections/resources_index'
+require_dependency 'underworld/dashboard/sections/resource_create'
+require_dependency 'underworld/dashboard/sections/resource_show'
+require_dependency 'underworld/dashboard/sections/resource_destroy'
+require_dependency 'underworld/dashboard/sections/sidebar'
+
+module Underworld::Dashboard
+  module DSL
+
+    extend ActiveSupport::Concern
+
+    include Underworld::Dashboard::Sections::Resource
+    include Underworld::Dashboard::Sections::ResourcesIndex
+    include Underworld::Dashboard::Sections::ResourceCreate
+    include Underworld::Dashboard::Sections::ResourceShow
+    include Underworld::Dashboard::Sections::ResourceDestroy
+    include Underworld::Dashboard::Sections::Sidebar
+
+    attr_accessor :_override_views
+
+    def _override_views
+      @_override_views ||= []
+    end
+
+    module ClassMethods
+      # override the default view for given views or the result
+      # of the given block, by the one from the application
+      def override_views(*views, &block)
+
+        define_method(:_override_views) do
+          result = views || []
+          result.concat(block.call) if block_given?
+          result
+        end
+
+      end
+    end
+  end
+end

data/lib/underworld/dashboard/dsl/base.rb

@@ -0,0 +1,133 @@
+require 'set'
+
+module Underworld::Dashboard::DSL
+  class Base
+    attr_reader(:action_buttons, :fields, :model, :default_scope,
+                :action_buttons)
+
+    # Base class for all the DSL property classes to be
+    # used as the yielded object inside each section DSL
+    # scope.
+    #
+    # For example the below code will yield an instance of
+    # one of this class children.
+    #
+    #  in_index do
+    #    # This will yield an instance of this class child
+    #  end
+    #
+    # The most important note in this class is that all the public
+    # methods that their name starts with an underscore (_) not meant to
+    # be used as DSL.
+    def initialize(model)
+      @action_buttons = []
+      @model          = model
+      @fields         = resolve_model_reflections
+      @fields_type    = {}
+    end
+
+    # Allow user to specify an array of model attributes to be used
+    # in respected section. For example attributes to show as header
+    # columns in index section
+    def attributes(*fields_name, **options, &block)
+      if options.include? :except
+        @fields = resolve_model_reflections.reject do |field|
+          options[:except].include? field.to_sym
+        end
+      elsif options.include? :append
+
+        @fields += options[:append]
+      else
+
+        # Check for valid field names
+        fields_name.each do |name|
+          unless @fields.include? name.to_s
+            raise ArgumentError, "can't find '#{name}' field for model '#{model}'."
+          end
+        end
+        # set new value for fields
+        @fields = fields_name.map(&:to_s) unless fields_name.empty?
+      end
+
+      @fields.concat(block.call.map(&:to_s)) if block_given?
+    end
+
+    # Return the default scope for current properties object.
+    # scope will be used to fetch all the records for the given
+    # section. The Default implementation belongs to index section
+    # and return a page aware list of all the objects.
+    #
+    # You can easily change it via the corresponding section dsl.
+    # For example in case of `index` section:
+    #
+    #  in_index do |index|
+    #    index.scope do |params|
+    #      YourModel.all
+    #    end
+    #
+    #    # or ...
+    #
+    #    scope :my_scope
+    #  end
+    #
+    #  private
+    #    def my_scope
+    #      YourModel.where(...)
+    #
+    #    end
+    #
+    # Arguments:
+    # * **params**: Is the same params passed to controller action.
+    def scope(name = nil, &block)
+      return @default_scope = block if block_given?
+      @default_scope = name.to_sym
+    end
+
+    # Define a new action on the `action` place of the current section
+    # **options**: Is a hash which contains the action button properties.
+    #
+    # `name`: Label to use with the button.
+    # `href`: The link href to use in the `a` tag
+    # `class`:  classes of the button.
+    # `icon_class`: font awesome icon to use in button.
+    def action_button(**options)
+      @action_buttons ||= []
+      @action_buttons << options
+      @action_buttons.uniq!
+    end
+
+  private
+
+    # Replace foreign key names with their reflection names
+    # and create an array of model fields
+    def resolve_model_reflections
+      # TODO: cach the result using and instance_var or something
+      reflections = model.reflections
+      columns     = Set.new model.column_names
+      new_fields  = Set.new
+      fields_to_remove = Set.new
+
+      reflections.each do |name, column|
+        has_many = ActiveRecord::Reflection::HasManyReflection
+        has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+
+        if !column.is_a?(has_many) && !column.is_a?(has_and_belongs_to_many)
+          new_fields << name.to_s
+          fields_to_remove << column.foreign_key.to_s
+        end
+      end
+
+      if model.respond_to? :attachment_definitions
+        # Paperclip is installed and model contains attachments
+        model.attachment_definitions.each do |name, _|
+          new_fields << name.to_s
+          ["file_name", "content_type", "file_size", "updated_at"].each do |x|
+            fields_to_remove << "#{name}_#{x}"
+          end
+        end
+      end
+
+      columns.union(new_fields) - fields_to_remove
+    end
+  end
+end

data/lib/underworld/dashboard/dsl/create.rb

@@ -0,0 +1,116 @@
+require_dependency 'underworld/dashboard/dsl/base'
+
+module Underworld::Dashboard::DSL
+  class Create < Base
+
+    def initialize(model)
+      super
+      @field_details = {}
+    end
+
+    # Specify attributes details, for example if you want to change a datetime
+    # field type to string you need to do like this:
+    #
+    #  in_form do
+    #    attributes_properties date: { as: :string }
+    #  end
+    def attributes_properties(**options)
+      options_set = Set.new options.keys.map(&:to_s)
+
+      unless options_set.subset? Set.new(@fields)
+        fail "You have to provide correct attribute names in" +
+             "'attributes_properties' for '#{@model}'."
+      end
+
+      # TODO: Check for valid value for each key
+      @field_details = options || {}
+    end
+
+    def _field_details
+      details = @field_details.dup
+
+      fields_for_form.each do |field|
+        if !details.include? field.to_sym
+
+          type = guess_field_type(field)
+          details[field.to_sym] = initialize_field(field.to_sym, type)
+        end
+      end
+
+      details
+    end
+
+    def fields_for_form
+      fields_name = @fields.dup
+
+      fields_name.delete('id')
+      fields_name.delete('created_at')
+      fields_name.delete('updated_at')
+
+      fields_name
+    end
+
+    private
+
+      def guess_field_type(field)
+        column = model.columns_hash[field.to_s]
+        return column.type.to_sym unless column.nil?
+
+        return :file if has_attachment? field.to_sym
+
+        has_many                = ActiveRecord::Reflection::HasManyReflection
+        has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+        reflection              = model.reflections[field.to_s]
+
+        unless reflection.nil?
+          return nil if reflection.is_a? has_many
+          return :multiple_select if reflection.is_a? has_and_belongs_to_many
+          :select
+        end
+      end
+
+      def has_attachment?(name)
+        if model.respond_to? :attachment_definitions
+          return true if model.attachment_definitions.keys.include? name
+        end
+
+        false
+      end
+
+      def initialize_field(name, type)
+        if respond_to?("setup_#{type}".to_sym, true)
+          return send("setup_#{type}", name)
+        end
+        { as: type.to_sym }
+      end
+
+      def setup_datetime(name)
+        { as: :string,
+          input_html: { class: 'datetimepicker' }
+        }
+      end
+
+      def setup_time(name)
+        { as: :string,
+          input_html: { class: 'timepicker' }
+        }
+      end
+
+      def setup_date(name)
+        { as: :string,
+          input_html: { class: 'datepicker1' }
+        }
+      end
+
+      def setup_multiple_select(name)
+        { as: :select,
+          input_html: { class: 'multiple select' }
+        }
+      end
+
+      def setup_integer(name)
+        { as: nil }
+      end
+
+  end
+end

data/lib/underworld/dashboard/dsl/form_fields_properties.rb

@@ -0,0 +1,62 @@
+module Underworld::Dashboard
+  class FormFieldsProperties
+
+    def initializer
+      @fields = {}
+    end
+
+    def fields=(all_fields)
+      fields.each do |name, field|
+        unless all_fields.include? name.to_s
+          raise ArgumentError, "'#{name}' is not a valid field"
+        end
+      end
+
+      all_fields.each do |name, field|
+        unless fields.include?(name.to_sym)
+
+          Rails.logger.debug("FIELD NAME: #{name}")
+          Rails.logger.debug("FIELD TYPE: #{field.type}")
+
+          if self.respond_to?("setup_#{field.type}".to_sym, true)
+            puts "sdasda" * 100
+            send("setup_#{field.type}", name)
+          end
+        end
+      end
+    end
+
+    def fields
+      @fields || {}
+    end
+
+    def []=(name, detail)
+      @fields ||= {}
+      @fields[name.to_sym] = detail
+    end
+
+    def [](index)
+      unless @fields.nil?
+        return @fields[index] || {}
+      end
+      {}
+    end
+
+    def method_missing(m, *args, &block)
+      @fields ||= {}
+      if self.respond_to? m
+        return self.send(m, *args, &block)
+      else
+        # FIXME: This probably is a bad idea. We should get the whole
+        # args
+        @fields[m] = args[0]
+      end
+    end
+
+    def to_hash
+      fields
+    end
+
+
+  end
+end

data/lib/underworld/dashboard/dsl/index.rb

@@ -0,0 +1,45 @@
+require_dependency 'underworld/dashboard/dsl/base'
+
+module Underworld::Dashboard::DSL
+  class Index < Base
+    attr_reader :tool_buttons
+
+    # Allow user to specify an array of model attributes to be used
+    # in respected section. For example attributes to show as header
+    # columns in index section
+    def attributes(*fields_name, **options, &block)
+      if options.include? :except
+        @fields = resolve_model_reflections.reject do |field|
+          options[:except].include? field.to_sym
+        end
+      elsif options.include? :append
+         @fields += options[:append]
+      else
+        # set new value for fields
+        @fields = fields_name.map(&:to_s) unless fields_name.empty?
+      end
+
+      @fields.concat(block.call.map(&:to_s)) if block_given?
+    end
+
+    # Define a new tool on the `tool` place of the index section
+    # **options**: Is a hash which contains the tool button properties.
+    #
+    # `name`:  name of the button. used as identifier
+    # `class`:  classes of the button.
+    # `icon_class`: font awesome icon to use in button.
+    # `remote`: whether
+    #
+    # You have to provide a block for this method which returns
+    # a string to be used as the **href** for the link
+    def tool_button(**options, &block)
+      fail 'You have to provide a block for `tool_button`' if !block_given?
+
+      options[:block] = block
+      @tool_buttons ||= {}
+      @tool_buttons[options[:name]] = options
+    end
+
+    alias_method :table_fields, :attributes
+  end
+end

data/lib/underworld/dashboard/dsl/show.rb

@@ -0,0 +1,6 @@
+require_dependency 'underworld/dashboard/dsl/base'
+
+module Underworld::Dashboard::DSL
+  class Show < Index
+  end
+end

data/lib/underworld/dashboard/dsl/update.rb

@@ -0,0 +1,6 @@
+require_dependency 'underworld/dashboard/dsl/base'
+
+module Underworld::Dashboard::DSL
+  class Update < Base
+  end
+end

data/lib/underworld/dashboard/helpers/box_helpers.rb

@@ -0,0 +1,129 @@
+module Underworld::Dashboard
+  module Helpers
+    module BoxHelpers
+
+      class Box
+        def footer(&block)
+          return @footer = nil unless block_given?
+          @footer = block
+        end
+
+        def body(&block)
+          @body = block
+        end
+
+        def footer_content
+          @footer
+        end
+
+        def body_content
+          @body
+        end
+      end
+
+      class Tabs
+
+        class Tab
+          attr_reader :title, :title_icon
+          attr_accessor :content, :id
+
+          def initialize(title, **options)
+            @title      = title
+            @active     = false
+            @active     = true if options[:active] == true
+            @title_icon = options[:title_icon]
+          end
+
+          def active?
+            @active
+          end
+        end
+
+        attr_reader :title_icon
+
+        def initialize(**options)
+          @tabs       = []
+          @title_icon = options[:title_icon]
+        end
+
+
+        def tab(title, **options, &block)
+          id  = @tabs.length
+          tab = Tab.new(title, **options)
+          tab.content = block
+          tab.id = id
+          @tabs << tab
+        end
+
+        def tabs
+          @tabs
+        end
+      end
+
+      def box(title = nil, **options)
+        content = Box.new
+
+        yield content
+
+        result = "<div class='box #{options[:box_class] || 'box-default'}'>" +
+          "<div class='box-header with-border'>" +
+          "<h3 class='box-title'>" +
+          title +
+          '</h3>'
+
+        unless options[:show_tools].nil?
+          result += "<div class='box-tools pull-right'>" +
+            "<button class='btn btn-box-tool' data-widget='collapse'>" +
+            "<i class='fa fa-minus'></i></button>" +
+            "</div><!-- /.box-tools -->"
+        end
+
+        result += "</div><!-- /.box-header -->" +
+          "<div class='box-body'>" +
+          capture(&content.body_content) +
+          "</div><!-- /.box-body -->"
+
+        unless content.footer_content.nil?
+          result += '<div class="box-footer">' +
+            content.footer_content +
+            "</div><!-- /.box-footer-->"
+        end
+
+        result += "</div><!-- /.box -->"
+
+        result.html_safe
+      end
+
+
+      def tabbed_box(title = nil, **options)
+        content = Tabs.new
+
+        yield content
+
+        result = "<div class='nav-tabs-custom'>" +
+          "<ul class='nav nav-tabs pull-right'>"
+
+        content.tabs.each do |tab|
+          active = nil
+          active = "class='active'" if tab.active?
+
+          result += "<li #{active}><a href='#tab_#{tab.id}-#{tab.id}' data-toggle='tab'>" +
+            "<i class='fa #{tab.title_icon}'></i> #{tab.title}</a></li>"
+        end
+
+        result += "<li class='pull-left header'><i class='fa #{options[:title_icon]}'></i>#{title}</li>" +
+          "</ul>" +
+          "<div class='tab-content'>"
+
+        content.tabs.each do |tab|
+          result += "<div class='tab-pane #{'active' if tab.active?}' id='tab_#{tab.id}-#{tab.id}'>" +
+            capture(&tab.content) +
+            "</div><!-- /.tab-pane -->"
+        end
+
+        result += "</div><!-- /.tab-content --></div>"
+        result.html_safe
+      end
+    end
+  end
+end