app_kit 0.0.1

data/lib/app_kit/dsl/application_dsl.rb

@@ -0,0 +1,32 @@
+module AppKit::Dsl::ApplicationDsl
+  # DSL method to set the application title. This is called from the
+  # initializer.
+  def title(title_text)
+    puts "title called"
+    config.application_title = title_text
+  end
+
+  # DSL method to disable user authentication. This is called from the
+  # initializer
+  def disable_authentication
+    config.authentication_enabled = false
+  end
+
+  # DSL method for configuring the dashboard. This is called from the
+  # initializer
+  def dashboard(&block)
+    AppKit.application.dashboard_view.instance_eval(&block)
+  end
+
+  # DSL method for creating custom naviation items. This is called from the
+  # initializer
+  def navigation_item(title, path_helper,options ={})
+    nav_item = AppKit::NavigationItem.new
+    nav_item.title = title
+    nav_item.path_helper = path_helper
+    nav_item.icon = options[:icon]
+    nav_item.position = options[:position] || :left
+    nav_item.controller = options[:controller]
+    navigation_items << nav_item
+  end
+end

data/lib/app_kit/dsl/resource_dsl.rb

@@ -0,0 +1,62 @@
+module AppKit::Dsl::ResourceDsl
+
+    # A DSL method for defining a new action.
+    #
+    # === Attributes
+    #
+    # * +name+ - The controller action to bind to.
+    # * +options+ - An optional hash of params.
+    # * +&block+ - The code to execute. This block is yielded the model instance
+    #
+    # === Examples
+    #   action :update do |record|
+    #       record.parent_record.update_information
+    #   end
+    #
+    def action(name, options={}, &block)
+      member_actions[name] = AppKit::Action.new(name, self, options, &block)
+    end
+
+    # A DSL method for defining fields and their options.
+    #
+    # @param name [Symbol] the field name. This should relate to a method name on the model.
+    # @param options [Hash] an optional hash to list field options. For a full list of field options see the AppKit::Field class.
+    # @param block [Block] If a block is passed a DSL can be used to define the fields settings, instead of passing them in the options hash.
+    # @example Define a new field
+    #   field :name, editable: false, display_in_details: false
+    def field(name, options={}, &block)
+      field = AppKit::Field.new(model, name, options, &block)
+      fields << field
+    end
+
+    # DSL method for displaying resources in the main navigation bar.
+    # @params val [boolean] - If true a menu item for this resrouce will be displayed in the main navigation menu.
+    # @param position [:left,:right] the position for the navigation item
+    def show_in_navigation(val=true, position = :left)
+      if val == true
+        nav_item = AppKit::NavigationItem.new
+        nav_item.resource = self
+        nav_item.position = position
+        nav_item.icon = self.navigation_icon
+        AppKit.application.navigation_items << nav_item
+      else
+        AppKit.application.navigation_items.delete_if {|i| i.resource == self}
+      end
+    end
+
+    # DSL method for defining before_actions on resources.
+    # @param action [Symbol] The action the before filter should execute for. Generally :new, :create, :update, or :destroy
+    # @param block [Block] A block to execute. This block is given the record object.
+    def before(action, &block)
+      before_actions[action] = block if block_given?
+    end
+
+    # DSL method for defining an icon to be used in the navigation menu for this resource.
+    # These icons use FontAwesome and should relate to the FontAwesome icon name.
+    # @param icon [String] The FontAwesome icon name to use.
+    # @example
+    #   icon 'list'
+    def icon(icon_name)
+      self.navigation_icon = icon_name
+    end
+end

data/lib/app_kit/dsl.rb

@@ -0,0 +1,37 @@
+module AppKit
+  def self.register(model, &block)
+    # create resource controller
+    return unless ActiveRecord::Base.connection.table_exists? model.table_name
+    resource_name = model.name.demodulize.underscore.pluralize
+    controller_name = model.name.demodulize.pluralize
+    controller = AppKit.const_set("#{controller_name}Controller",
+                                  Class.new(ResourcesController))
+    controller.resource = Resource.new(model)
+    # process resource dsl
+    controller.resource.instance_exec(&block)  if block_given?
+    controller.resource.controller_name = controller.controller_name
+    controller.prepend_view_path("app/views/#{model.name.underscore.pluralize}")
+
+    # draw controller routes
+    AppKit::Engine.routes.append do
+      resources resource_name.to_sym do
+        controller.resource.has_many_associations.each do |assoc|
+          resources assoc.name.to_s.pluralize, only: [:new]
+        end
+        member do
+          get 'history' => :history, :as => :history
+          get 'version/:version_id' => :version, :as => :version
+          controller.resource.member_actions.each do |name,action|
+            get action.name, action: 'perform_action', action_name: 'deactivate'
+          end
+        end
+        collection do
+          get 'versions/:version_id' => :show_version, :as => :show_version
+        end
+      end
+    end
+  end
+  def self.setup(&block)
+      AppKit.application.setup!(&block)
+  end
+end

data/lib/app_kit/engine.rb

@@ -0,0 +1,15 @@
+module AppKit
+  class Engine < ::Rails::Engine
+    load_path = File.expand_path('app/app_kit', Rails.root)
+    isolate_namespace AppKit
+    config.watchable_dirs[load_path]
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+
+  end
+
+end

data/lib/app_kit/field.rb

@@ -0,0 +1,194 @@
+module AppKit
+  # The field class manages individual attributes on a model.
+  # == Fields DSL
+  #
+  # Fields are defined inside resource DSL. A field must have a name given by a symbol which relates to
+  # a specific method on the model class and can take a variety of options to configure the way it is handled.
+  #
+  # === Field Options
+  #
+  # * +editable+ - If set to false a fieild will not be visible in the create/edit forms and it will not be whitelisted
+  # * +formatter+ - A symbol for the fomatter to use when displaying this field.
+  #   * +:currency+ - Formats using ActiveSupports number_to_currency method.
+  #   * +:integer+ - Formats to humanized numbers.
+  #   * +:date+ - Formats to +m/d/yy+ format
+  #   * +:datetime+ - Formats to +m/d/yy+ hh:mm:ss
+  #   * +:string+ - Returns the value unmodified.
+  #   The default formatter for a given field is determened by its data type.
+  # * +show_in_table+ - If set to false the field will not appear in tabular lists of the records.
+  # * +show_in_detail+ - If set to false the field will not appear in the key/value details view in the #show action.
+  # * +hide+ - A convienence method. If set to false the +display_in_table+, +display_in_detail+, and +editable+ options will all be set to false.
+  # * +editor+ - The editor to use when this field is displayed on in the edit/create forms. The default editor is selected based on the field's data type.
+  #
+  # @example DSL inline options
+  #   field :total_amount, :formatter => :currency, editable: false, display_in_table: false
+  # @example DSL block options
+  #   field :total_amount do
+  #       formatter :currency
+  #       editable false
+  #       display_in_table false
+  #   end
+  class Field
+
+    # A symbol which relates to the method on the model this field gets it's value from.
+    attr_accessor :name
+    # A boolean value indicating if this field is the foreign_key of an association
+    attr_accessor :foreign_key
+    # The data_type of this field. Retrieved from the column definition.
+    attr_accessor :data_type
+    # The association object for this field if it is a foreign_key
+    attr_accessor :association
+    # A custom field to sort by.
+    attr_accessor :sort_field
+    # Used for storing enum options for enum field types
+    # This value should be set to a hash of options
+
+    # DSL option for flagging the field as editable or not.
+    # @param val [Boolean] if set to false the field will not be displayed in the edit/create form.
+    attr_writer :editable
+    def editable(val=nil)
+      return @editable if val.nil?
+      @editable = val
+    end
+
+    # DSL option for setting the formatting used for a field.
+    # @param val [Symbol]
+    attr_writer :formatter
+    def formatter(val=nil)
+      return @formatter if val.nil?
+      @formatter = val
+    end
+
+    attr_writer :show_in_table
+    # DSL option
+    # @param val [Boolean] - If set to false the item will not appear
+    # in tables.
+    def show_in_table(val = nil)
+      return @show_in_table if val.nil?
+      @show_in_table = val
+    end
+
+
+    attr_writer :show_in_details
+    # DSL option
+    # @param val [Boolean] - If set to false the field will not be
+    # displayed in the details panel of the #show action.
+    def show_in_details(val=nil)
+      return @show_in_details if val.nil?
+      @show_in_details = val
+    end
+
+    attr_writer :show_in_filters
+    # DSL Option
+    # @param val [Boolean] - If set to false the field will not be
+    # displayed in the filter panel
+    def show_in_filters(val=nil)
+      return @show_in_filters if val.nil?
+      @show_in_filters = val
+    end
+
+    # The display name for this field. By default it will be a humanized
+    # form of the method name.
+    attr_writer :display_name
+    def display_name(val = nil)
+      if val != nil
+        @display_name = val
+      else
+        @display_name
+      end
+    end
+
+    # DSL option - The editor to use when editing this field.
+    attr_writer :editor
+    def editor(val=nil)
+      return @editor if val.nil?
+      @editor = val
+    end
+
+    # a proc used to display the value of the field. For dynamic virtual
+    # fields defined with a block
+    attr_accessor :display_proc
+
+    # This class is generally created by the Resource DSL and it should
+    # not need to be created directly.
+    # @param model [ActiveRecord::Base] The model this field belongs to.
+    # @param name [Symbol] The method this field gets it's value from.
+    # @param options [Hash] The options which should be set for this field.
+    def initialize(model, name, options={}, &block)
+      @name = name
+      @data_type = model.columns_hash[name.to_s].try(:type) || :string
+      @show_in_details = true
+      @show_in_table = true
+      @show_in_filters = true
+      @editable = true
+      @formatter = data_type
+      @display_name = name.to_s.humanize
+      options.each {|k,v| send(k,v) }
+      if block_given?
+        @editable = false
+        @show_in_filters = false
+        @display_proc = block
+      end
+      @association = model.reflect_on_all_associations.find{|i| i.foreign_key.to_sym == name}
+    end
+
+    # genereated options for editor fields
+    def editor_options
+      options = { :label => display_name, :as => editor }
+      if enum
+        options[:enum] = enum
+      end
+      options
+    end
+
+    attr_writer :enum
+    def enum(value = nil)
+      if value != nil
+        editor :enum
+        @enum = value
+      else
+        return @enum
+      end
+    end
+
+    def value_for_record(record)
+      if @display_proc
+        @display_proc.call(record)
+      elsif @enum
+        @enum[record.send(name).to_sym]
+      else
+        record.send(name)
+      end
+    end
+
+    # Determins if the field is the foreign_key of an association.
+    # @returns Boolean
+    def is_foreign_key?
+      association.present?
+    end
+
+    # Retrieves the assoicated record for this field. If it is a foreign_key.
+    # @return An active record object on the otherside of the association.
+    def associated_record
+      assoication.active_record
+    end
+
+    # A conveinence method for completely hiding a field from the UI.
+    # @param val [Boolean] If true the item will not be displayed in tables, details, and will not be editable.
+    def hide(val = true)
+      show_in_details !val
+      show_in_table !val
+      editable !val
+    end
+
+    # DSL method for setting the sort name for this field.
+    # @param val [Symbol] The name of a column to sort this field by.
+    def sort_field(val = nil)
+      if val == nil
+        @sort_field || name
+      else
+        @sort_field = val
+      end
+    end
+  end
+end

data/lib/app_kit/filter_form_builder.rb

@@ -0,0 +1,82 @@
+class AppKit::FilterFormBuilder < ActionView::Helpers::FormBuilder
+
+  def filter_params
+    @template.params[param_set.to_sym].try(:first)
+  end
+
+  def param_set
+    "#{@object_name.underscore}_filter"
+  end
+  def get_field_name(field, tag="value")
+    "#{param_set}[][#{field.name}][#{tag}]"
+  end
+  def label(field)
+    css = ""
+    if filter_params
+      if filter_params[field.name]["value"].present?
+        css << " highlight"
+      end
+    end
+    @template.label param_set, field.name, field.display_name, class: css
+  end
+  def search_input(field)
+    value = filter_params[field.name]["value"] rescue nil
+    @template.search_field_tag get_field_name(field), value
+  end
+
+  def predicate_select(field)
+    select_options_array = case field.data_type
+                           when :integer, :decimal
+                             [
+                               ['equals', 'eq'],
+                               ['greater than','gt'],
+                               ['less than', 'lt'],
+                               ['not equal', 'nq']
+                             ]
+                           else
+                             [
+                               ['contains', 'cont'],
+                               ['doesn\'t contain', 'ncont']
+                             ]
+                           end
+    @template.select_tag get_field_name(field, 'condition'),
+      @template.options_for_select(select_options_array)
+  end
+
+
+  def filter_field(field)
+    case field.data_type
+    when :date, :datetime
+      @template.content_tag :div, class: 'range-filter date-range' do
+        @template.search_field_tag(get_field_name(field,'from'), nil, placeholder: 'from') +
+          @template.search_field_tag(get_field_name(field,'to'), nil, placeholder: 'to')
+      end
+    when :boolean
+      value = filter_params[field.name]["value"] rescue nil
+      options = @template.options_for_select([['Any', ''],['Yes', 'true'], ['No', 'false']], value)
+      @template.select_tag get_field_name(field, 'value'), options
+    when :integer
+      if field.is_foreign_key?
+        @template.collection_select get_field_name(field), nil,
+          field.association.klass.all, :id, :to_s,
+          prompt: 'Any'
+      else
+        predicate_filter(field)
+      end
+    else
+      predicate_filter(field)
+    end
+  end
+
+  def filter(field)
+    label(field) + filter_field(field)
+  end
+
+
+  def predicate_filter(field)
+    @template.content_tag :div, class: 'predicate-filter' do
+      @template.content_tag(:div, predicate_select(field), class: 'predicate-select') +
+        @template.content_tag(:div, search_input(field), class: 'value')
+    end
+  end
+end

data/lib/app_kit/inputs/enum_input.rb

@@ -0,0 +1,13 @@
+class EnumInput < SimpleForm::Inputs::CollectionSelectInput
+  def input(wrapper_options = nil)
+    collection = options[:enum]
+    label_method = :last
+    value_method = :first
+    merged_input_options = merge_wrapper_options(input_html_options,
+                                                 wrapper_options)
+    @builder.collection_select(
+      attribute_name, collection, value_method, label_method,
+      input_options, merged_input_options
+    )
+  end
+end

data/lib/app_kit/kaminari_patch.rb

@@ -0,0 +1,9 @@
+module Kaminari
+  module Helpers
+    class Tag
+      def page_url_for(page)
+         AppKit::Engine.routes.url_helpers.url_for @params.merge(@param_name => (page <= 1 ? nil : page), :only_path=>true).symbolize_keys
+      end
+    end
+  end
+end

data/lib/app_kit/navigation_item.rb

@@ -0,0 +1,28 @@
+class AppKit::NavigationItem
+  attr_accessor :resource, :title, :path_helper, :position, :controller
+  attr_writer :icon
+
+  def initialize
+    @position = :left
+  end
+
+  def get_path
+    if has_resource?
+      polymorphic_path([app_kit, resource])
+    else
+      main_app.send(path_helper)
+    end
+  end
+
+  def icon
+    if has_resource?
+      resource.navigation_icon
+    else
+      @icon
+    end
+  end
+
+  def has_resource?
+    resource != nil
+  end
+end

data/lib/app_kit/resource.rb

@@ -0,0 +1,118 @@
+module AppKit
+  # The resource class manages a model and contains most of the functionality for
+  # dynamically interacting with the model. It also contains all the settings given
+  # in the DSL.
+  # The resource DSL is evaluated within this class.
+  class Resource
+    include AppKit::Dsl::ResourceDsl
+    attr_writer :hidden_fields, :editors, :formatters, :member_actions,
+      :editable_fields
+
+    # The model class that this resource manages.
+    attr_accessor :model
+
+    # A string tha represents a icon used in the navigation menu.
+    # Taken from FontAwesome and is set using the #icon DSL method.
+    attr_accessor :navigation_icon
+
+    # The name of the controller this resource manages.
+    attr_accessor :controller_name
+
+
+
+    def member_actions; @member_actions ||= {}; end
+
+    # Looks up a resoruce by its model class.
+    #
+    # === Examples
+    #
+    #   AppKit::Resource.find(User)
+    def self.find(model)
+      if model.is_a? Symbol
+        return AppKit.application.resources.find{|r|
+          r.model.model_name.name.underscore.to_sym == model
+        }
+      end
+      AppKit.application.resources.find{|r| r.model == model}
+    end
+
+    # A list of fields defined by the DSL
+    attr_writer :fields
+    def fields; @fields ||= []; end
+
+    # A list of before_actions defined in the DSL. These actions
+    # are executed in the controller before views are rendered. They
+    # should be blocks which are given an instance of the model.
+    #
+    # This list should be managed from within the DSL and there should
+    # be no need to add things to it directly. See AppKit::Action.
+    attr_writer :before_actions
+    def before_actions; @before_actions ||= {}; end
+
+    # Initilization method
+    #
+    # === Attributes
+    #
+    # * +model+ - The model class this resource will manage.
+    def initialize(model)
+      @model = model
+      AppKit.application.resources << self
+      @navigation_position = :left
+    end
+
+    # Helper method for displaying the resource name.
+    # @returns A human readable string for the given resource
+    # @example A resource called against a UserOption model.
+    #   resource.display_name #=> "User option"
+    #
+    def display_name
+      model.name.demodulize.underscore.humanize
+    end
+
+    # Helper method for displaying the resource name.
+    # @returns A human readable plural string for the given resource
+    # @example A resource called against a UserOption model.
+    #   resource.display_name #=> "User options"
+    #
+    def plural_display_name
+      display_name.pluralize
+    end
+
+    # A list of the fields that should be displayed in tables.
+    # All fields by default are included in this list, unless the
+    # display_in_table option is set to false.
+    # @return [array] An of Field objects with display_in_table set to true
+    def table_fields
+      fields.each.select(&:show_in_table)
+    end
+
+    # A list of fields that should be displayed in the #SHOW action or detail view
+    # All fields are included in this list by default, unless the
+    # display_in_detail option is set to false in the field options.
+    def detail_fields
+      fields.each.select(&:show_in_details)
+    end
+
+    # A list of all fields that can be displayed in the edit/create form. All fields
+    # are included in this list unless the editable option in the field configuration is
+    # set to false.
+    def editable_fields
+      fields.each.select(&:editable)
+    end
+
+    # A list of all fields that can be displayed in the filter panel.
+    def filter_fields
+      fields.each.select(&:show_in_filters)
+    end
+
+    # A list of all has_many associations the model has.
+    def has_many_associations
+      model.reflect_on_all_associations.select{|a| a.macro == :has_many unless a.name == :versions }
+    end
+
+    def actions_for_record?(record)
+      member_actions.select{|name, a| a.enabled_for_record?(record)}.count > 0
+    end
+
+  end
+end

data/lib/app_kit/user_resource.rb

@@ -0,0 +1,13 @@
+AppKit.register AppKit::User do
+  show_in_navigation true, :right
+  icon 'users'
+  field :first_name
+  field :last_name
+  field :email
+  field :password, show_in_details: false, show_in_table: false
+  field :password_confirmation, show_in_details: false, show_in_table: false
+
+  before(:show) {
+    @versions = @record.versions.order(:created_at => :desc).page(params[:page]).per(20)
+  }
+end

data/lib/app_kit/version.rb

@@ -0,0 +1,3 @@
+module AppKit
+  VERSION = "0.0.1"
+end

data/lib/app_kit/views/base.rb

@@ -0,0 +1,8 @@
+module AppKit::Views
+  class Base
+    def table(resource, options={}, &block)
+      table = Table.new(resource, options)
+      items.push table
+    end
+  end
+end

data/lib/app_kit/views/dashboard.rb

@@ -0,0 +1,10 @@
+class AppKit::Views::Dashboard < AppKit::Views::Base
+  attr_accessor :items
+  def initialize
+    @items = []
+  end
+  def table(resource, options={}, &block)
+    options[:filter] = false
+    super(resource, options, &block)
+  end
+end

data/lib/app_kit/views/table.rb

@@ -0,0 +1,33 @@
+class AppKit::Views::Table
+  attr_accessor :resource, :resource_scope, :page, :filter_enabled
+  attr_writer :title
+
+  def initialize(resource, options = {})
+    resource = AppKit::Resource.find(resource) if resource.is_a? Symbol
+    @resource = resource
+    @resource_scope = options[:resource_scope]
+    @title = options[:title]
+    @records = options[:records]
+    @page = options[:page] || 1
+    @filter_enabled = (options[:filter].nil? ? true : false)
+  end
+
+  def icon
+    resource.navigation_icon || 'list'
+  end
+
+  def title
+     @title || resource.plural_display_name
+  end
+
+  def records
+    unless @records
+      @records = @resource.model
+      @records = @records.send(resource_scope) if resource_scope
+      @records.page(page)
+    end
+    @records.page(page)
+  end
+
+
+end