hyper_admin 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 892fb43df29ba674cc93e307fe0da6468f913183
-  data.tar.gz: 85c2871d89a0bf17ae5a66e209f4d1b86fbf5b40
+  metadata.gz: e9caafcf2dc9aa7815c539b2ff800a272bd93c25
+  data.tar.gz: fee5bc8be042bcdd4fc478f88c73de2503b346af
 SHA512:
-  metadata.gz: 33baa5048c224fc55d765c94e9c3aed2bebbaa83b0a7905fc0236ba6287276c362322d1147d1ed20d29695555f767aba0216593c489a11fea3da18a47a836410
-  data.tar.gz: a3db6f9479aa407f55115b2a86177c7676591fb95639b1dfe4ac440d2cbf798581062ab44d7bc245c2878b979ed12947686beb52779bbaa4ecf73783233088f4
+  metadata.gz: 1fdba92fa922efa18cd304f21c2335c02d32861532778892f6d8006c4b10d7ea64f42fd8031d9ef776e77266136ce7f47caac2947fef8a3e62f4abcf822357ea
+  data.tar.gz: c03f7a813cf6774a8d3efb65af36923d04105d0ca3685cd85bf1a3e4491f4542c7e8d67547d7d94e4904611a01bf4f25ea52b30c94cc04b07c24d3fc3cd02295

data/README.md

@@ -1,3 +1,159 @@
 # HyperAdmin
 
-This project rocks and uses MIT-LICENSE.
+HyperAdmin is an admin interface solution for Ruby on Rails. It works pretty
+much as a mountable engine, except it always mounts under _/admin_. This is
+currently not configurable.
+
+## Installation
+
+Simply put the gem in your Rails application's Gemfile:
+
+```ruby
+gem 'hyper_admin'
+```
+
+Then, install the bundle as usual:
+
+```
+$ bundle install
+```
+
+Finally, mount HyperAdmin into your application. Put this in your
+_config/routes.rb_ file:
+
+```ruby
+HyperAdmin.routes self
+mount HyperAdmin::Engine, at: '/admin'
+```
+
+As mentioned above, you must mount it under _/admin_ for the time being. In a
+later version, this will be configurable.
+
+## Usage
+
+To register models that should be accessible through the admin, all you need to
+do is register them with a single line of code. Do this in any Ruby file(s) you
+want under _app/admin/_, such as _app/admin/article.rb_ or
+_app/admin/person.rb_. When the application boots, HyperAdmin will check each
+file under the _app/admin/_. To register a resource:
+
+```ruby
+HyperAdmin.register NameOfYourResource
+```
+
+For instance:
+
+```ruby
+HyperAdmin.register Article
+```
+
+With this in place, you can now visit _/admin/articles_ in your application and
+start managing your articles.
+
+### Configuring views
+
+When registering resources, it is also possible to customize what fields should
+show up where and (to some degree) how they should be displayed. For instance,
+we might want to only show the ID, title and publication date of an article in
+the index view. For that, we would pass in a block to `register` and specify
+which columns to display on the index view, like this:
+
+```ruby
+HyperAdmin.register Article do
+  index do
+    column :id
+    column :title
+    column :published_at
+  end
+end
+```
+
+Note that the order matters here, so this could also be used to force an order
+of attributes to be displayed. In the example above, HyperAdmin would know the
+types of the attributes because of how it is registered in the database.
+However, some types cannot be determined from the database alone. URL fields and
+e-mail fields, for instance, are stored as text, so they will be treated as text
+by default. It is possible to tell HyperAdmin what type of field you're
+specifying by using the `type` keyword:
+
+```ruby
+HyperAdmin.register Article do
+  index do
+    column :id
+    column :title
+    column :published_at
+    column :author_email, type: :email
+  end
+end
+```
+
+The **email** type will create a “mailto”-style link in the index and show
+views, and an `<input type="email">` in the form. Likewise, the “url” type will
+create a regular link in index/show and an `<input type="url">` in forms.
+
+Lastly, it is also possible to customize the labeling of the attributes in each
+view using the `human` keyword:
+
+```ruby
+HyperAdmin.register Article do
+  index do
+    column :id
+    column :title
+    column :published_at, human: "Publication date"
+    column :author_email, type: :email
+  end
+end
+```
+
+Note that if `human` is not specified, HyperAdmin will fetch the attribute name
+from the currently active locale, which is recommended most of the time. `human`
+is available for special cases where you want a label other than the localized
+name of the attribute.
+
+Customizing the show and form pages work the same way as the index pages, but
+using the `row` and `field` methods instead, respectively. A fully customized
+resource registration might look something like this:
+
+```ruby
+HyperAdmin.register Article do
+  index do
+    column :id
+    column :title
+    column :published_at, human: "Publication date"
+  end
+
+  show do
+    row :id, human: "Article ID"
+    row :title
+    row :body
+    row :published_at, human: "Publication date"
+
+    column :author_email, type: :email
+  end
+
+  form do
+    field :title
+    field :body
+    field :published_at
+    field :author_email, type: :email
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Check out the develop branch (`git checkout develop`)
+3. Create your feature branch (`git checkout -b feature/my-new-feature`)
+4. Commit your changes (`git commit -am 'Add my new feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+
+## Credits
+
+Hyper made this. We're a digital communications agency with a passion for good
+code, and if you're using HyperAdmin we probably want to hire you.
+
+## License
+
+HyperAdmin is available under the MIT license. See LICENSE.md for more details.

data/app/assets/javascripts/hyper_admin/angularjs/controllers/form_ctrl.js.coffee

@@ -15,18 +15,28 @@ angular.module("hyperadmin")
       Restangular.one(target).get().then (resource) =>
         @resource = resource
 
-        $scope.resourceClass.attributes.forEach (attr) =>
+        $scope.resourceClass.form_attributes.forEach (attr) =>
           if attr.type == "date" or attr.type == "datetime"
             if @resource[attr.key]
               @resource[attr.key] = new Date @resource[attr.key]
 
     [ "id", "created_at", "updated_at" ].forEach (key) ->
-      _.remove $scope.resourceClass.attributes, (attr) ->
+      _.remove $scope.resourceClass.form_attributes, (attr) ->
         attr.key == key
 
+    prettifyErrors = (errors) ->
+      result = { }
+      for own attr of errors
+        attrSchema = _.find $scope.resourceClass.form_attributes, (attribute) =>
+          attribute.key == attr
+
+        result[attrSchema.human] = errors[attr]
+
+      result
+
     @submit = =>
       onError = (response) =>
-        @errors = response.data
+        @errors = prettifyErrors response.data
 
       onSuccess = (resource) =>
         $state.go "^.show", id: resource.id

data/app/assets/javascripts/hyper_admin/angularjs/directives/form/resource_form.js.coffee

@@ -6,7 +6,7 @@ angular.module("hyperadmin")
     <form-errors errors="formCtrl.errors"></form-errors> 
 
     <form class="form-horizontal" name="form" ng-submit="formCtrl.submit()" novalidate>
-      <form-input-group ng-repeat="attribute in resourceClass.attributes"
+      <form-input-group ng-repeat="attribute in resourceClass.form_attributes"
         resource="formCtrl.resource"
         attr="attribute.key"
         errors="formCtrl.errors[attribute.key]"
@@ -24,4 +24,4 @@ angular.module("hyperadmin")
       resourceClass: "=resourceClass"
     controller: ($scope) ->
       [ "id", "created_at", "updated_at" ].forEach (attr) ->
-        delete $scope.resourceClass.attributes[attr]
+        delete $scope.resourceClass.form_attributes[attr]

data/app/assets/javascripts/hyper_admin/angularjs/directives/table/resource_table.js.coffee

@@ -4,14 +4,14 @@ angular.module("hyperadmin")
 <table class="table table-striped">
   <thead>
     <tr>
-      <th ng-repeat="attribute in resourceClass.attributes">
+      <th ng-repeat="attribute in resourceClass.index_attributes">
         {{ attribute.human }}
       </th>
       <th>Actions</th>
     </tr>
   </thead>
   <tbody>
-    <tr table-row attributes="resourceClass.attributes"
+    <tr table-row attributes="resourceClass.index_attributes"
       ng-repeat="resource in resources" resource="resource">
     </tr>
   </tbody>

data/app/controllers/hyper_admin/resource_classes_controller.rb

@@ -4,15 +4,20 @@ module HyperAdmin
 
     def index
       collection = ::HyperAdmin.application.resources
-      @resource_classes = collection.resources.values.map(&:resource_class)
+      @resource_classes = collection.resources.values
 
       respond_with @resource_classes
     end
 
     def show
       collection = ::HyperAdmin.application.resources
-      resource_classes = collection.resources.values.map(&:resource_class)
-      @resource_class = resource_classes.find { |c| c.model_name.route_key == params[:id] }
+      resource_classes = collection.resources.values
+
+      @resource_class = resource_classes.find do |c|
+        c.resource_class.model_name.route_key == params[:id]
+      end
+
+      fail ActiveRecord::RecordNotFound unless @resource_class
 
       respond_with @resource_class
     end

data/app/views/admin/resources/show.html.erb

@@ -15,7 +15,7 @@
   <div class="col-xs-12">
     <div class="well">
       <dl class="dl-horizontal">
-        <dt ng-repeat-start="attribute in showCtrl.resource_class.attributes">
+        <dt ng-repeat-start="attribute in showCtrl.resource_class.show_attributes">
           {{ attribute.human }}
         </dt>
         <dd ng-repeat-end>

data/app/views/hyper_admin/resource_classes/index.json.jbuilder

@@ -1,23 +1,9 @@
-def infer_type_from_attribute(resource_class, attribute)
-  return :email if attribute == "email"
-  return :url   if attribute == "url"
-
-  resource_class.columns_hash[attribute].type
-end
-
 json.array! @resource_classes do |resource_class|
-  json.menu_label resource_class.model_name.human(count: 2)
-  json.singular resource_class.model_name.singular
-  json.singular_human resource_class.model_name.human(count: 1)
-  json.plural resource_class.model_name.plural
-  json.plural_human resource_class.model_name.human(count: 2)
+  real_resource = resource_class.resource_class
 
-  attributes = resource_class.attribute_names.map do |attr|
-    {
-      key: attr,
-      human: resource_class.human_attribute_name(attr),
-      type: infer_type_from_attribute(resource_class, attr)
-    }
-  end
-  json.attributes attributes
+  json.menu_label real_resource.model_name.human(count: 2)
+  json.singular real_resource.model_name.singular
+  json.singular_human real_resource.model_name.human(count: 1)
+  json.plural real_resource.model_name.plural
+  json.plural_human real_resource.model_name.human(count: 2)
 end

data/app/views/hyper_admin/resource_classes/show.json.jbuilder

@@ -1,21 +1,71 @@
 def infer_type_from_attribute(resource_class, attribute)
-  return :email if attribute == "email"
-  return :url   if attribute == "url"
+  attribute = attribute.to_s
 
   resource_class.columns_hash[attribute].type
 end
 
-json.menu_label @resource_class.model_name.human(count: 2)
-json.singular @resource_class.model_name.singular
-json.singular_human @resource_class.model_name.human(count: 1)
-json.plural @resource_class.model_name.plural
-json.plural_human @resource_class.model_name.human(count: 2)
+real_resource = @resource_class.resource_class
 
-attributes = @resource_class.attribute_names.map do |attr|
-  {
-    key: attr,
-    human: @resource_class.human_attribute_name(attr),
-    type: infer_type_from_attribute(@resource_class, attr)
-  }
-end
-json.attributes attributes
+json.menu_label real_resource.model_name.human(count: 2)
+json.singular real_resource.model_name.singular
+json.singular_human real_resource.model_name.human(count: 1)
+json.plural real_resource.model_name.plural
+json.plural_human real_resource.model_name.human(count: 2)
+
+show_attributes = if @resource_class.show_config
+                    @resource_class.show_config.each.map do |config|
+                      {
+                        key: config[:attribute],
+                        human: config[:human],
+                        type: config[:type]
+                      }
+                    end
+                  else
+                    real_resource.attribute_names.map do |attr|
+                      {
+                        key: attr,
+                        human: real_resource.human_attribute_name(attr),
+                        type: infer_type_from_attribute(real_resource, attr)
+                      }
+                    end
+                  end
+
+index_attributes = if @resource_class.index_config
+                     @resource_class.index_config.each.map do |config|
+                       {
+                         key: config[:attribute],
+                         human: config[:human],
+                         type: config[:type]
+                       }
+                     end
+                   else
+                     real_resource.attribute_names.map do |attr|
+                       {
+                         key: attr,
+                         human: real_resource.human_attribute_name(attr),
+                         type: infer_type_from_attribute(real_resource, attr)
+                       }
+                     end
+                   end
+
+form_attributes = if @resource_class.form_config
+                     @resource_class.form_config.each.map do |config|
+                       {
+                         key: config[:attribute],
+                         human: config[:human],
+                         type: config[:type]
+                       }
+                     end
+                   else
+                     real_resource.attribute_names.map do |attr|
+                       {
+                         key: attr,
+                         human: real_resource.human_attribute_name(attr),
+                         type: infer_type_from_attribute(real_resource, attr)
+                       }
+                     end
+                   end
+
+json.show_attributes show_attributes
+json.index_attributes index_attributes
+json.form_attributes form_attributes

data/lib/hyper_admin.rb

@@ -10,7 +10,6 @@ module HyperAdmin
 
     delegate :register, to: :application
     delegate :routes,   to: :application
-    delegate :setup,    to: :application
 
     def application
       @application ||= HyperAdmin::Application.new

data/lib/hyper_admin/application.rb

@@ -13,8 +13,8 @@ module HyperAdmin
       prevent_rails_autoloading_load_paths
     end
 
-    def register(resource_class)
-      resource = @resources.add resource_class
+    def register(resource_class, &block)
+      resource = @resources.add resource_class, &block
       create_resource_controller resource
     end
 

data/lib/hyper_admin/dsl.rb

@@ -0,0 +1,9 @@
+require 'hyper_admin/dsl/parser'
+require 'hyper_admin/dsl/show'
+require 'hyper_admin/dsl/index'
+require 'hyper_admin/dsl/form'
+
+module HyperAdmin
+  module DSL
+  end
+end

data/lib/hyper_admin/dsl/form.rb

@@ -0,0 +1,26 @@
+module HyperAdmin
+  module DSL
+    class Form
+
+      def initialize(resource_class)
+        @resource_class = resource_class
+        @fields = []
+      end
+
+      def field(attribute, type: infer_type(attribute), human: human_name(attribute))
+        @fields << { attribute: attribute, type: type, human: human }
+      end
+
+      private
+
+      def infer_type(attribute)
+        @resource_class.columns_hash[attribute.to_s].type
+      end
+
+      def human_name(attribute)
+        @resource_class.human_attribute_name attribute
+      end
+
+    end
+  end
+end