tennpipes-su 3.6.6

data/lib/tennpipes-su/bootstrap-less/wells.less

@@ -0,0 +1,29 @@
+//
+// Wells
+// --------------------------------------------------
+
+
+// Base class
+.well {
+  min-height: 20px;
+  padding: 19px;
+  margin-bottom: 20px;
+  background-color: @well-bg;
+  border: 1px solid @well-border;
+  border-radius: @border-radius-base;
+  .box-shadow(inset 0 1px 1px rgba(0,0,0,.05));
+  blockquote {
+    border-color: #ddd;
+    border-color: rgba(0,0,0,.15);
+  }
+}
+
+// Sizes
+.well-lg {
+  padding: 24px;
+  border-radius: @border-radius-large;
+}
+.well-sm {
+  padding: 9px;
+  border-radius: @border-radius-small;
+}

data/lib/tennpipes-su/generators/actions.rb

@@ -0,0 +1,78 @@
+module Tennpipes
+  module Generators
+    ##
+    # Generator action definitions for the admin panel.
+    #
+    module Admin
+      ##
+      # Important tasks for setting up or configuring the admin application.
+      #
+      module Actions
+        ##
+        # Tell us which orm we are using.
+        #
+        def orm
+          fetch_component_choice(:orm).to_sym rescue :activerecord
+        end
+        alias :adapter :orm
+
+        ##
+        # Tell us which rendering engine you are using.
+        #
+        def ext
+          fetch_component_choice(:admin_renderer).to_sym rescue :haml
+        end
+
+        ##
+        # Tell us for now which orm we support
+        #
+        def supported_orm
+          [:minirecord, :datamapper, :activerecord, :mongomapper, :mongoid, :couchrest, :sequel, :ohm, :dynamoid]
+        end
+
+        ##
+        # Tell us for now which rendering engine we support.
+        #
+        def supported_ext
+          [:haml, :slim, :erb]
+        end
+
+        ##
+        # Add access_control permission in our app.rb.
+        #
+        def add_project_module(controller)
+          permission = "      role.project_module :#{controller}, '/#{controller}'\n"
+          inject_into_file destination_root(@admin_path+'/app.rb'),  permission, :after => "access_control.roles_for :admin do |role|\n"
+        end
+
+        ##
+        # Remove from access_control permissions.
+        #
+        def remove_project_module(controller)
+          path = destination_root(@admin_path+'/app.rb')
+          say_status :replace, @admin_path+'/app.rb', :red
+          content = File.binread(path)
+          content.gsub!(/^\s+role\.project_module :#{controller}, '\/#{controller}'\n/, '')
+          File.open(path, 'wb') { |f| f.write content }
+        end
+
+        ##
+        # Returns the app_name for the application at root.
+        #
+        # @param [String] app
+        #   folder name of application.
+        #
+        # @return [String] module name for application.
+        #
+        # @example
+        #   fetch_app_name('subapp')
+        #
+        # @api public
+        def fetch_app_name(app='app')
+          app_path = destination_root(app, 'app.rb')
+          @app_name ||= File.read(app_path).scan(/module\s(.*?)\n/).flatten[0]
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-su/generators/admin_app.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+module Tennpipes
+  module Generators
+    ##
+    # Defines the generator for creating a new admin app.
+    #
+    class AdminApp < Thor::Group
+
+      # Add this generator to our tennpipes-init
+      Tennpipes::Generators.add_generator(:admin, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      # Defines the "banner" text for the CLI.
+      def self.banner; "tennpipes-init admin"; end
+
+      # Include related modules.
+      include Thor::Actions
+      include Tennpipes::Generators::Actions
+      include Tennpipes::Generators::Admin::Actions
+
+      # Look for custom template files in a generators folder under the project root.
+      def source_paths
+        if File.exist? destination_root('generators', 'templates')
+          ["#{destination_root('generators')}", File.expand_path(File.dirname(__FILE__))]
+        else
+          [File.expand_path(File.dirname(__FILE__))]
+        end
+      end
+
+      desc "Description:\n\n\ttennpipes-init admin generates a new Tennpipes Admin application"
+
+      class_option :skip_migration, :aliases => "-s", :default => false, :type => :boolean
+      # class_option :models_path,     :desc => 'The models destination path', :default => '.', :type => :string
+      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+      class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
+      class_option :renderer, :aliases => '-e', :desc => "Rendering engine (erb, haml, slim)", :type => :string
+      class_option :admin_model, :aliases => '-m', :desc => "The name of model for access controlling", :default => 'Account', :type => :string
+      class_option :admin_name,  :aliases => '-a', :desc => 'The admin application name and path', :default => 'admin', :type => :string
+
+      # Copies over the Tennpipes base admin application.
+      def create_admin
+        self.destination_root = options[:root]
+        if in_app_root?
+          unless supported_orm.include?(orm)
+            say "<= At the moment, Tennpipes only supports #{supported_orm.join(" or ")}. Sorry!", :yellow
+            raise SystemExit
+          end
+
+          tmp_ext = options[:renderer] || fetch_component_choice(:renderer)
+          unless supported_ext.include?(tmp_ext.to_sym)
+            say "<= Your are using '#{tmp_ext}' and for admin we only support '#{supported_ext.join(', ')}'. Please use -e haml or -e erb or -e slim", :yellow
+            raise SystemExit
+          end
+
+          # Get the app's namespace.
+          @app_name = fetch_app_name
+
+          # setup admin app name
+          @admin_name = options[:admin_name].classify
+          @admin_path = options[:admin_name].underscore
+
+          store_component_choice(:admin_renderer, tmp_ext)
+
+          self.behavior = :revoke if options[:destroy]
+
+          empty_directory destination_root(@admin_path)
+
+          # Setup Admin Model
+          @model_name     = options[:admin_model].classify
+          @model_singular = @model_name.underscore
+          @model_plural   = @model_singular.pluralize
+
+          directory "templates/app",       destination_root(@admin_path)
+          directory "templates/assets",    destination_root("public", @admin_path)
+          template  "templates/app.rb.tt", destination_root(@admin_path + "/app.rb")
+          inject_into_file destination_root('config/apps.rb'), "\nTennpipes.mount(\"#{@app_name}::#{@admin_name}\", :app_file => Tennpipes.root('#{@admin_path}/app.rb')).to(\"/#{@admin_path}\")\n", :before => /^Tennpipes.mount.*\.to\('\/'\)$/
+          unless options[:destroy]
+            insert_middleware 'ActiveRecord::ConnectionAdapters::ConnectionManagement', @admin_path if [:minirecord, :activerecord].include?(orm)
+          end
+
+          params = [
+            @model_singular, "name:string", "surname:string", "email:string", "crypted_password:string", "role:string",
+            "-a=#{options[:models_path]}",
+            "-r=#{options[:root]}"
+          ]
+          params << "-s" if options[:skip_migration]
+          params << "-d" if options[:destroy]
+
+          Tennpipes::Generators::Model.start(params)
+          column = Struct.new(:name, :type)
+          columns = [:id, :name, :surname, :email].map { |col| column.new(col) }
+          column_fields = [
+            { :name => :name,                  :field_type => :text_field },
+            { :name => :surname,               :field_type => :text_field },
+            { :name => :email,                 :field_type => :text_field },
+            { :name => :password,              :field_type => :password_field },
+            { :name => :password_confirmation, :field_type => :password_field },
+            { :name => :role,                  :field_type => :text_field }
+          ]
+
+          unless options[:destroy]
+            admin_app = Tennpipes::Generators::AdminPage.new([@model_singular], :root => options[:root], :destroy => options[:destroy], :admin_model => @model_singular, :admin_name => @admin_name)
+            admin_app.default_orm = Tennpipes::Admin::Generators::Orm.new(@model_singular, orm, columns, column_fields)
+            admin_app.invoke_all
+          end
+
+          # TODO See this, there's something wrong it's not being applied properly or something because test_account_model_generator last test fails.
+          template "templates/account/#{orm}.rb.tt", destination_root("models", "#{@model_singular}.rb"), :force => true
+
+          if File.exist?(destination_root("db/seeds.rb"))
+            run "mv #{destination_root('db/seeds.rb')} #{destination_root('db/seeds.old')}"
+          end
+          template "templates/account/seeds.rb.tt", destination_root("db/seeds.rb")
+
+          empty_directory destination_root(@admin_path+"/controllers")
+          empty_directory destination_root(@admin_path+"/views")
+          empty_directory destination_root(@admin_path+"/views/base")
+          empty_directory destination_root(@admin_path+"/views/layouts")
+          empty_directory destination_root(@admin_path+"/views/sessions")
+          empty_directory destination_root(@admin_path+"/views/errors")
+
+          template "templates/#{ext}/app/base/index.#{ext}.tt",          destination_root(@admin_path+"/views/base/index.#{ext}")
+          template "templates/#{ext}/app/layouts/application.#{ext}.tt", destination_root(@admin_path+"/views/layouts/application.#{ext}")
+          template "templates/#{ext}/app/layouts/error.#{ext}.tt",       destination_root(@admin_path+"/views/layouts/error.#{ext}")
+          template "templates/#{ext}/app/sessions/new.#{ext}.tt",        destination_root(@admin_path+"/views/sessions/new.#{ext}")
+          # Custom error.
+          template "templates/#{ext}/app/errors/403.#{ext}.tt",          destination_root(@admin_path+"/views/errors/403.#{ext}")
+          template "templates/#{ext}/app/errors/404.#{ext}.tt",          destination_root(@admin_path+"/views/errors/404.#{ext}")
+          template "templates/#{ext}/app/errors/500.#{ext}.tt",          destination_root(@admin_path+"/views/errors/500.#{ext}")
+
+          unless options[:destroy]
+            add_project_module @model_plural
+            require_dependencies('bcrypt')
+          end
+
+          # A nicer select box.
+          # TODO FIXME This doesn't make much sense in here. Review.
+          # gsub_file destination_root("admin/views/#{@model_plural}/_form.#{ext}"), "f.text_field :role, :class => :text_field", "f.select :role, :options => access_control.roles"
+
+          # Destroy account only if not logged in.
+          gsub_file destination_root(@admin_path+"/controllers/#{@model_plural}.rb"), "if #{@model_singular}.destroy", "if #{@model_singular} != current_account && #{@model_singular}.destroy"
+          return if self.behavior == :revoke
+
+          instructions = []
+          instructions << "Run 'bundle'"
+          if [:activerecord, :datamapper, :sequel].include?(orm)
+            instructions << "Run 'bundle exec rake db:create' if you have not created a database yet"
+            instructions << "Run 'bundle exec rake db:migrate'"
+          end
+          instructions << "Now repeat after me... 'ohm mani padme hum', 'ohm mani padme hum'... :)" if orm == :ohm
+          instructions << "Run 'bundle exec rake db:seed'"
+          instructions << "Visit the admin panel in the browser at '/#{@admin_path}'"
+          instructions.map! { |i| "  #{instructions.index(i)+1}) #{i}" }
+
+          say
+          say "="*65, :green
+          say "The admin panel has been mounted! Next, follow these steps:", :green
+          say "="*65, :green
+          say instructions.join("\n")
+          say "="*65, :green
+          say
+        else
+          say "You are not at the root of a Tennpipes application! (config/boot.rb not found)"
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-su/generators/admin_page.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+module Tennpipes
+  module Generators
+    ##
+    # Defines the generator for creating a new admin page.
+    #
+    class AdminPage < Thor::Group
+      attr_accessor :default_orm
+
+      # Add this generator to our tennpipes-init.
+      Tennpipes::Generators.add_generator(:admin_page, self)
+
+      # Define the source template root.
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      # Defines the "banner" text for the CLI.
+      def self.banner; "tennpipes-init admin_page [model]"; end
+
+      # Include related modules.
+      include Thor::Actions
+      include Tennpipes::Generators::Actions
+      include Tennpipes::Generators::Admin::Actions
+
+      # Look for custom template files in a generators folder under the project root.
+      def source_paths
+        if File.exist? destination_root('generators')
+          ["#{destination_root('generators')}", File.expand_path(File.dirname(__FILE__))]
+        else
+          [File.expand_path(File.dirname(__FILE__))]
+        end
+      end
+
+      desc "Description:\n\n\ttennpipes-init admin_page model(s)"
+      argument :models, :desc => "The name(s) of your model(s)", :type => :array
+      class_option :skip_migration, :aliases => "-s", :default => false, :type => :boolean
+      class_option :root, :desc => "The root destination", :aliases => '-r', :type => :string
+      class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
+      class_option :admin_name,  :aliases => '-a', :desc => 'The admin application name and path', :default => 'admin', :type => :string
+      # Show help if no argv given.
+      require_arguments!
+
+      # Create controller for admin.
+      def create_controller
+        self.destination_root = options[:root]
+        if in_app_root?
+          @app_name = fetch_app_name
+          @admin_name = options[:admin_name].classify
+          @admin_path = options[:admin_name].underscore
+          @admin_model = options[:admin_model]
+          models.each do |model|
+            @orm = default_orm || Tennpipes::Admin::Generators::Orm.new(model, adapter)
+            self.behavior = :revoke if options[:destroy]
+            empty_directory destination_root(@admin_path+"/views/#{@orm.name_plural}")
+
+            template "templates/page/controller.rb.tt",       destination_root(@admin_path+"/controllers/#{@orm.name_plural}.rb")
+            template "templates/#{ext}/page/_form.#{ext}.tt", destination_root(@admin_path+"/views/#{@orm.name_plural}/_form.#{ext}")
+            template "templates/#{ext}/page/edit.#{ext}.tt",  destination_root(@admin_path+"/views/#{@orm.name_plural}/edit.#{ext}")
+            template "templates/#{ext}/page/index.#{ext}.tt", destination_root(@admin_path+"/views/#{@orm.name_plural}/index.#{ext}")
+            template "templates/#{ext}/page/new.#{ext}.tt",   destination_root(@admin_path+"/views/#{@orm.name_plural}/new.#{ext}")
+
+            options[:destroy] ? remove_project_module(@orm.name_plural) : add_project_module(@orm.name_plural)
+          end
+        else
+          say "You are not at the root of a Tennpipes application! (config/boot.rb not found)"
+        end
+      end
+    end
+  end
+end

data/lib/tennpipes-su/generators/orm.rb

@@ -0,0 +1,172 @@
+module Tennpipes
+  module Admin
+    ##
+    # Contains all admin related generator functionality.
+    #
+    module Generators
+      # Defines a generic exception for the admin ORM handler.
+      class OrmError < StandardError; end
+
+      ##
+      # Defines the generic ORM management functions used to manipulate data for admin.
+      class Orm
+        attr_reader :klass_name, :klass, :name_plural, :name_singular, :orm, :name_param
+
+        def initialize(name, orm, columns=nil, column_fields=nil)
+          name            = name.to_s
+          @klass_name     = name.underscore.camelize
+          @klass          = @klass_name.constantize rescue nil
+          @name_param     = name.underscore.gsub(/\//, '_')
+          @name_singular  = name.underscore.gsub(/^.*\//, '') # convert submodules i.e. FooBar::Jank.all # => jank
+          @name_plural    = @name_singular.pluralize
+          @orm            = orm.to_sym
+          @columns        = columns
+          @column_fields  = column_fields
+          raise OrmError, "Model '#{klass_name}' could not be found!\nPerhaps you would like to run 'bundle exec tennpipes g model #{klass_name}' to create it first?" if @columns.nil? && @klass.nil?
+        end
+
+        def activerecord?
+          case orm
+          when :activerecord, :minirecord then true
+          else false
+          end
+        end
+
+        def field_type(type)
+          type = :string if type.nil? # couchrest-Hack to avoid the next line to fail
+          type = type.to_s.demodulize.downcase.to_sym unless type.is_a?(Symbol)
+          case type
+            when :integer, :float, :decimal   then :text_field
+            when :string                      then :text_field
+            when :text                        then :text_area
+            when :boolean                     then :check_box
+            else :text_field
+          end
+        end
+
+        Column = Struct.new(:name, :type) # for compatibility
+
+        def columns
+          @columns ||= case orm
+            when :activerecord then @klass.columns
+            when :minirecord   then @klass.columns
+            when :datamapper   then @klass.properties.map { |p| dm_column(p) }
+            when :couchrest    then @klass.properties
+            when :mongoid      then @klass.fields.values.reject { |col| %w[_id _type].include?(col.name) }
+            when :mongomapper  then @klass.keys.values.reject { |key| key.name == "_id" } # On MongoMapper keys are an hash
+            when :sequel       then @klass.db_schema.map { |k,v| v[:type] = :text if v[:db_type] =~ /^text/i; Column.new(k, v[:type]) }
+            when :ohm          then @klass.attributes.map { |a| Column.new(a.to_s, :string) } # ohm has strings
+            when :dynamoid     then @klass.attributes.map { |k,v| Column.new(k.to_s, v[:type]) }
+            else raise OrmError, "Adapter #{orm} is not yet supported!"
+          end
+        end
+
+        def dm_column(p)
+          case p
+          when DataMapper::Property::Text
+            Column.new(p.name, :text)
+          when DataMapper::Property::Boolean
+            Column.new(p.name, :boolean)
+          when DataMapper::Property::Integer
+            Column.new(p.name, :integer)
+          when DataMapper::Property::Decimal
+            Column.new(p.name, :decimal)
+          when DataMapper::Property::Float
+            Column.new(p.name, :float)
+          when DataMapper::Property::String
+            Column.new(p.name, :string)
+          else #if all fails, lets assume its stringish
+            Column.new(p.name, :string)
+          end
+        end
+
+        def column_fields
+          excluded_columns = %w[created_at updated_at]
+          case orm
+            when :mongoid then excluded_columns << '_id'
+            else excluded_columns << 'id'
+          end
+
+          column_fields    = columns.dup
+          column_fields.reject! { |column| excluded_columns.include?(column.name.to_s) }
+          @column_fields ||= column_fields.map do |column|
+            { :name => column.name, :field_type => field_type(column.type) }
+          end
+        end
+
+        def all
+          "#{klass_name}.all"
+        end
+
+        def find(params=nil)
+          case orm
+            when :activerecord, :minirecord, :mongomapper, :mongoid, :dynamoid then "#{klass_name}.find(#{params})"
+            when :datamapper, :couchrest then "#{klass_name}.get(#{params})"
+            when :sequel, :ohm then "#{klass_name}[#{params}]"
+            else raise OrmError, "Adapter #{orm} is not yet supported!"
+          end
+        end
+
+        def build(params=nil)
+          if params
+            "#{klass_name}.new(#{params})"
+          else
+            "#{klass_name}.new"
+          end
+        end
+
+        def save
+          case orm
+            when :sequel then "(@#{name_singular}.save rescue false)"
+            else "@#{name_singular}.save"
+          end
+        end
+
+        def update_attributes(params=nil)
+          case orm
+            when :activerecord, :minirecord, :mongomapper, :mongoid, :couchrest, :dynamoid then "@#{name_singular}.update_attributes(#{params})"
+            when :datamapper, :ohm then "@#{name_singular}.update(#{params})"
+            when :sequel then "@#{name_singular}.modified! && @#{name_singular}.update(#{params})"
+            else raise OrmError, "Adapter #{orm} is not yet supported!"
+          end
+        end
+
+        def destroy
+          case orm
+            when :ohm then "#{name_singular}.delete"
+            else "#{name_singular}.destroy"
+          end
+        end
+
+        def find_by_ids(params=nil)
+          case orm
+            when :ohm then "#{klass_name}.fetch(#{params})"
+            when :datamapper then "#{klass_name}.all(:id => #{params})"
+            when :sequel then "#{klass_name}.where(:id => #{params})"
+            when :mongoid then "#{klass_name}.find(#{params})"
+            when :couchrest then "#{klass_name}.all(:keys => #{params})"
+            when :dynamoid then "#{klass_name}.find(#{params})"
+            else find(params)
+          end
+        end
+
+        def multiple_destroy(params=nil)
+          case orm
+            when :ohm then "#{params}.each(&:delete)"
+            when :sequel then  "#{params}.destroy"
+            when :datamapper then "#{params}.destroy"
+            when :couchrest, :mongoid, :mongomapper, :dynamoid then "#{params}.each(&:destroy)"
+            else "#{klass_name}.destroy #{params}"
+          end
+        end
+
+        def has_error(field)
+          case orm
+            when :datamapper, :ohm, :sequel then "@#{name_singular}.errors.key?(:#{field}) && @#{name_singular}.errors[:#{field}].count > 0"
+            else "@#{name_singular}.errors.include?(:#{field})"
+          end
+        end
+      end
+    end
+  end
+end