padrino-admin 0.5.0 → 0.6.1

data/lib/padrino-admin/ext_js/config.rb

@@ -32,140 +32,154 @@ module Padrino
       end
     end
 
-    # This class it's used for write in a new and simple way json.
-    # 
-    # In ExtJs framework generally each component have a configuration written in json.
-    # 
-    # Write this config in ruby it's not the best choice think this example:
-    # 
-    #   # A Generic grid config in JavaScript:
-    #   var gridPanel = new Ext.grid.GridPanel({
-    #     bbar: gridPanelPagingToolbar,
-    #     clicksToEdit: 1,
-    #     cm: gridPanelColumnModel,
-    #     region: "center",
-    #     sm: gridPanelCheckboxSelectionModel,
-    #     viewConfig: {"forceFit":true},
-    #     plugins: [new Ext.grid.Search()],
-    #     border: false,
-    #     tbar: gridPanelToolbar,
-    #     id: "grid-accounts",
-    #     bodyBorder: false,
-    #     store: gridPanelGroupingStore,
-    #     view: gridPanelGroupingView
-    #   });
-    # 
-    #   # A Gneric grid config in Ruby:
-    #   { :bbar => Padrino::ExtJs::Variable.new('gridPanelPagingToolbar'), :clicksToEdit => 1, 
-    #     :cm => Padrino::ExtJs::Variable.new('gridPanelColumnModel'), :region => "center",
-    #     :sm => Padrino::ExtJs::Variable.new('gridPanelCheckboxSelectionModel'),
-    #     :viewConfig => { :forceFit => true }, plugins => [Padrino::ExtJs::Variable.new('new Ext.grid.Search()'].
-    #     :border => false ... more more code...
-    # 
-    # As you can see writing json in pure ruby (in this case with hash) require much time and is
-    # <tt>less</tt> readable.
-    # 
-    # For this reason we build an ExtJs Config, that basically it's an yaml file with
-    # some new great functions so the example above will be:
-    # 
-    #   # A Generic grid config in ExtJs Config:
-    #   gridPanel:
-    #     bbar: !js gridPanelPagingToolbar
-    #     clicksToEdit: 1,
-    #     cm: !js gridPanelColumnModel
-    #     region: center
-    #     sm: !js gridPanelCheckboxSelectionModel
-    #     viewConfig:
-    #       forceFit: true
-    #     plugins: [!js new Ext.grid.Search()]
-    #     border: false
-    #     tbar: !js gridPanelToolbar
-    #     id: grid-accounts
-    #     bodyBorder: false
-    #     store: !js gridPanelGroupingStore
-    #     view: !js gridPanelGroupingView
-    # 
-    # Now you see that it's more readable, simple and coincise!
-    # 
-    # But our ExtJs config can act also as an xml or an erb partial. See this code:
-    # 
-    #   # A template
-    #   tempate:
-    #     tbar:
-    #       here: a custom config
-    #     grid:
-    #       viewConfig:
-    #         forceFit: true
-    #       plugins: [!js new Ext.grid.Search()]
-    #       border: false  
-    # 
-    # We can "grep" this config in our template with:
-    #   
-    #   # A generic grid
-    #   gridPanel:
-    #     <<: %template/grid
-    #     border: true
-    # 
-    # The result will be:
-    # 
-    #   gridPanel:
-    #     viewConfig:
-    #       forceFit: true
-    #     plugins: [!js new Ext.grid.Search()]
-    #     border: true # overidden
-    # 
-    # See our test for more complex examples.
-    # 
-    class Config < Hash
-
-      # Initialize a new config parsing an Hash
-      def initialize(data)
-        @data   = data
-        parsed  = parse(@data)
-        super
-        replace parsed
-      end
+    # Json Pretty Printer.
+    # Thanks to http://github.com/techcrunch/json_printer
+    class JsonPrinter
+      attr_reader :buf, :indent
 
-      # Load a new config from an yml file and return a parsed hash.
-      def self.load_file(path, binding=nil)
-        self.load(File.read(path), binding)
+      # ==== Arguments
+      # obj<Object>::
+      #   The object to be rendered into JSON.  This object and all of its 
+      #   associated objects must be either nil, true, false, a String, a Symbol,
+      #   a Numeric, an Array, or a Hash.
+      #
+      # ==== Returns
+      # <String>::
+      #   The pretty-printed JSON ecoding of the given <i>obj</i>.  This string
+      #   can be parsed by any compliant JSON parser without modification.
+      #
+      # ==== Examples
+      # See <tt>JsonPrinter</tt> docs.
+      #
+      def self.render(obj, indent=1)
+        indent = " "*indent
+        new(obj, indent).buf
       end
 
-      # Load a new config from a yaml "string" and return a parsed hash.
-      def self.load(string, binding=nil)
-        self.new YAML.parse(ERB.new(string).result(binding))
-      end
 
-    private
-      def parse(node=nil, key=nil)
-        case node.value
-          when String
-            if node.value =~ /^%{1}(.*)/
-              node = parse(@data.select($1).first)
-            end
-            node.respond_to?(:transform) ? node.transform : node
-          when Hash
-            parsed = {}
-            node.value.each do |k,v| 
-              if k.value == "<<"
-                node = parse(v)
-                if node.is_a?(Hash)
-                  node.merge!(parsed)
-                end
-                parsed = node
+      private
+        # Execute the JSON rendering of <i>obj</i>, storing the result in the 
+        # <tt>buf</tt>.
+        #
+        def initialize(obj, indent="")
+          @buf = ""
+          @indent = indent
+          render(obj)
+        end
+
+        # Increase the indentation level.
+        #
+        def indent_out
+          @indent << " "
+        end
+
+        # Decrease the indendation level.
+        #
+        def indent_in
+          @indent.slice!(-1, 1)
+        end
+
+        # Append the given <i>str</i> to the <tt>buf</tt>.
+        #
+        def print(str)
+          @buf << str
+        end
+
+        # Recursive rendering method.  Primitive values, like nil, true, false, 
+        # numbers, symbols, and strings are converted to JSON and appended to the
+        # buffer.  Enumerables are treated specially to generate pretty whitespace.
+        #
+        def render(obj)
+          # We can't use a case statement here becuase "when Hash" doesn't work for
+          # ActiveSupport::OrderedHash - respond_to?(:values) is a more reliable
+          # indicator of hash-like behavior.
+          if NilClass === obj
+            print("null")
+
+          elsif TrueClass === obj
+            print("true")
+
+          elsif FalseClass === obj
+            print("false")
+
+          elsif String === obj
+            print(escape_json_string(obj))
+
+          elsif Symbol === obj
+            print("\"#{obj}\"")
+
+          elsif Numeric === obj
+            print(obj.to_s)
+
+          elsif Time === obj
+            print(obj.to_s)
+
+          elsif obj.respond_to?(:keys)
+            print("{")
+            indent_out
+            last_key = obj.keys.last
+            obj.each do |(key, val)|
+              render(key)
+              case val
+              when Hash, Array
+                indent_out
+                print(":\n#{indent}")
+                render(val)
+                indent_in
               else
-                parsed[k.value] = parse(v)
+                print(": ")
+                render(val)
               end
+              print(",\n#{indent}") unless key == last_key
             end
-            parsed
-          when Array
-            parsed = []
-            node.value.each do |v|
-              node = parse(v)
-              node.is_a?(Array) ? parsed.concat(node) : parsed.push(node)
+            indent_in
+            print("}")
+
+          elsif Array === obj
+            print("[")
+            indent_out
+            last_index = obj.size - 1
+            obj.each_with_index do |elem, index|
+              render(elem)
+              print(",\n#{indent}") unless index == last_index
             end
-            parsed
+            indent_in
+            print("]")
+
+          else
+            raise "unrenderable object: #{obj.inspect}"
+          end
         end
+
+        # Special JSON character escape cases.
+        ESCAPED_CHARS = {
+          "\010" =>  '\b',
+          "\f"   =>  '\f',
+          "\n"   =>  '\n',
+          "\r"   =>  '\r',
+          "\t"   =>  '\t',
+          '"'    =>  '\"',
+          '\\'   =>  '\\\\',
+          '>'    =>  '\u003E',
+          '<'    =>  '\u003C',
+          '&'    =>  '\u0026'}
+
+        # String#to_json extracted from ActiveSupport, using interpolation for speed.
+        #
+        def escape_json_string(str)
+          begin
+            "\"#{
+            str.gsub(/[\010\f\n\r\t"\\><&]/) { |s| ESCAPED_CHARS[s] }.
+                gsub(/([\xC0-\xDF][\x80-\xBF]|
+                       [\xE0-\xEF][\x80-\xBF]{2}|
+                       [\xF0-\xF7][\x80-\xBF]{3})+/nx) do |s|
+                  s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/, '\\\\u\&')
+                end
+            }\""
+          rescue Encoding::CompatibilityError
+            rawbytes = str.dup.force_encoding 'ASCII-8BIT'
+            escape_json_string(rawbytes)
+          end
       end
     end
   end

data/lib/padrino-admin/generators/actions.rb

@@ -0,0 +1,16 @@
+module Padrino
+  module Generators
+    module Actions
+      # For access control permissions
+      def access_control(name)
+        (<<-RUBY)
+      role.project_module :#{name} do |project|
+        project.menu :list, "/admin/#{name}.js"
+        project.menu :new,  "/admin/#{name}/new"
+      end
+
+        RUBY
+      end
+    end
+  end
+end

data/lib/padrino-admin/generators/admin_app.rb

@@ -0,0 +1,61 @@
+module Padrino
+  module Generators
+
+    class AdminApp < Thor::Group
+
+      # Add this generator to our padrino-gen
+      Padrino::Generators.add_generator(:admin, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      def self.banner; "padrino-gen backend"; end
+
+      # Include related modules
+      include Thor::Actions
+      include Padrino::Generators::Actions
+
+      desc "Description:\n\n\tpadrino-gen controller generates a new Padrino Admin"
+
+      class_option :root,    :aliases => '-r', :default => nil,     :type    => :string
+      class_option :path,    :aliases => '-p', :type    => :string, :default => "admin"
+      class_option :destroy, :aliases => '-d', :default => false,   :type    => :boolean
+
+      # Copies over the Padrino base admin application
+      def create_admin
+        if in_app_root?(options[:root])
+          @app_path = options[:path]
+          @orm = fetch_component_choice(:orm, options[:root]).to_sym rescue :datamapper
+
+          orm_short = case @orm
+            when :datamapper    then :dm
+            when :activerecord  then :ar
+            when :mongomapper   then :mm
+            when :couchdb       then :cd
+            when :sequel        then :sq
+          end
+
+          say "A the moment we only support datamapper. Sorry!" and exit unless @orm == :datamapper
+
+          self.behavior = :revoke if options[:destroy]
+          directory("app/", File.join(options[:path]))
+          template "templates/models/account.rb.tt", app_root_path("/app/models/account.rb")
+          template "templates/db/seeds.rb.tt", app_root_path("/db/seeds.rb")
+          append_file app_root_path("config/apps.rb"),  "\nPadrino.mount(\"Admin\").to(\"/#{@app_path}\")"
+
+          say ""
+          say "Your admin now is installed, now follow this steps:"
+          say ""
+          say "   - edit your config/database.rb"
+          say "   - run padrino rake #{orm_short}:migrate"
+          say "   - run padrino rake seed"
+          say ""
+          say "That's all"
+        else
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)" and exit unless in_app_root?
+        end
+      end
+
+    end
+
+  end
+end

data/lib/padrino-admin/generators/admin_page.rb

@@ -0,0 +1,55 @@
+module Padrino
+  module Generators
+
+    class AdminPage < Thor::Group
+
+      # Add this generator to our padrino-gen
+      Padrino::Generators.add_generator(:admin_page, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      def self.banner; "padrino-gen backend_page [Model]"; end
+
+      # Include related modules
+      include Thor::Actions
+      include Padrino::Generators::Actions
+
+      desc "Description:\n\n\tpadrino-gen backend_page YourModel"
+      argument :model, :desc => "The name of your model"
+      class_option :admin_path, :aliases => '-p', :type => :string, :default => "admin"
+      class_option :root,       :aliases => '-r', :type => :string
+      class_option :destroy,    :aliases => '-d', :default => false, :type => :boolean
+
+      # Show help if no argv given
+      def self.start(given_args=ARGV, config={})
+        given_args = ["-h"] if given_args.empty?
+        super
+      end
+
+      # Create controller for admin
+      def create_controller
+        if in_app_root?(options[:root])
+          @model_name     = model
+          @model_klass    = model.constantize
+          @model_plural   = model.to_s.downcase.pluralize
+          @model_singular = model.to_s.downcase
+          @app_root       = File.join(options[:root] || '.', options[:admin_path])
+          self.behavior   = :revoke if options[:destroy]
+          template "templates/controller.rb.tt",     app_root_path(options[:admin_path], "/controllers/#{@model_plural}.rb")
+          template "templates/views/_form.haml.tt",  app_root_path(options[:admin_path], "/views/#{@model_plural}/_form.haml")
+          template "templates/views/edit.haml.tt",   app_root_path(options[:admin_path], "/views/#{@model_plural}/edit.haml")
+          template "templates/views/grid.js.erb.tt", app_root_path(options[:admin_path], "/views/#{@model_plural}/grid.js.erb")
+          template "templates/views/new.haml.tt",    app_root_path(options[:admin_path], "/views/#{@model_plural}/new.haml")
+          template "templates/views/store.jml.tt",   app_root_path(options[:admin_path], "/views/#{@model_plural}/store.jml")
+          inject_into_file app_root_path("#{options[:admin_path]}/app.rb"),  access_control(@model_plural), :before => "      # Put before other permissions [don't delete this line!!!]"
+          empty_directory app_root_path(options[:admin_path], "/views/#{@model_plural}")
+          include_component_module_for(:test, options[:root])
+          generate_controller_test(model.downcase.pluralize, options[:root])
+        else
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)" and return unless in_app_root?
+        end
+      end
+    end
+
+  end
+end

data/lib/padrino-admin/generators/app/app.rb.tt

@@ -0,0 +1,31 @@
+class Admin < Padrino::Application
+  configure do
+    # Application-specific configuration options
+    # set :sessions, false     # Enabled by default
+    # set :log_to_file, true   # Log to file instead of stdout (default is stdout in development)
+    # set :reload, false       # Reload application files (default in development)
+    # disable :padrino_helpers # Disables padrino markup helpers (enabled by default)
+    # disable :flash           # Disables rack-flash (enabled by default)
+    layout false
+    enable  :authentication
+    disable :store_location
+    set :use_orm, <%= @orm.inspect %>
+    set :login_page, "/<%= @app_path %>/sessions/new"
+
+    access_control.roles_for :any do |role|
+      role.allow "/sessions"
+    end
+
+    access_control.roles_for :admin do |role, account|
+      role.allow "/"
+
+      role.project_module :accounts do |project|
+        project.menu :list, "/<%= @app_path %>/accounts.js"
+        project.menu :new,  "/<%= @app_path %>/accounts/new"
+      end
+
+      # Put before other permissions [don't delete this line!!!]
+    end
+
+  end
+end

data/lib/padrino-admin/generators/app/controllers/accounts.rb

@@ -0,0 +1,37 @@
+Admin.controllers :accounts do
+
+  get :index, :respond_to => [:js, :json] do
+    @store = Account.column_store(options.views, "accounts/store")
+    case content_type
+      when :js    then render 'accounts/grid.js'
+      when :json  then @store.store_data(params)
+    end
+  end
+
+  get :new do
+    @account = Account.new
+    render 'accounts/new'
+  end
+
+  post :create, :respond_to => :js do
+    @account = Account.create(params[:account])
+    show_messages_for(@account)
+  end
+
+  get :edit, :with => :id do
+    @account = Account.first(:conditions => { :id => params[:id] })
+    render 'accounts/edit'
+  end
+
+  put :update, :with => :id, :respond_to => :js do
+    @account = Account.first(:conditions => { :id => params[:id] })
+    @account.update_attributes(params[:account])
+    show_messages_for(@account)
+  end
+
+  delete :destroy, :respond_to => :json do
+    accounts = Account.all(:conditions => { :id => params[:ids].split(",") })
+    errors   = accounts.map { |account| I18n.t("admin.general.cantDelete", :record => account.id) unless account.destroy }.compact
+    { :success => errors.empty?, :msg => errors.join("<br />") }.to_json
+  end
+end

data/lib/padrino-admin/generators/app/controllers/base.rb

@@ -0,0 +1,11 @@
+Admin.controllers do
+
+  get :index do
+    render "base/index"
+  end
+
+  get :dashboard do
+    render "base/dashboard"
+  end
+
+end

data/lib/padrino-admin/generators/app/controllers/javascripts.rb

@@ -0,0 +1,10 @@
+Admin.controllers :javascripts do
+
+  get :admin, :respond_to => :js do
+    render 'javascripts/admin.js'
+  end
+
+  get :locale, :respond_to => :js do
+    render 'javascripts/locale.js'
+  end
+end

data/lib/padrino-admin/generators/app/controllers/sessions.rb

@@ -0,0 +1,21 @@
+Admin.controllers :sessions do
+  
+  get :new do
+    render "/sessions/new"
+  end
+
+  post :create do
+    if account = Account.authenticate(params[:email], params[:password])
+      set_current_account(account)
+      redirect url_for(:index)
+    else
+      flash[:notice] = "Login or password wrong."
+      redirect url_for(:sessions_new)
+    end
+  end
+
+  get :destroy do
+    set_current_account(nil)
+    render "/sessions/new"
+  end
+end