Class: Padrino::Admin::Generators::Orm

### Home Classes Methods

### In Files

- lib/padrino-admin/generators/orm.rb

### Parent

Object

### Methods

- ::new
- #activerecord?
- #all
- #build
- #column_fields
- #columns
- #destroy
- #dm_column
- #field_type
- #find
- #find_by_ids
- #has_error
- #multiple_destroy
- #save
- #update_attributes

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- Padrino
- Padrino::Admin
- Padrino::Admin::AccessControl
- Padrino::Admin::AccessControl::Authorization
- Padrino::Admin::AccessControl::Base
- Padrino::Admin::AccessControl::ProjectModule
- Padrino::Admin::AccessControlError
- Padrino::Admin::Generators
- Padrino::Admin::Generators::Orm
- Padrino::Admin::Generators::OrmError
- Padrino::Admin::Helpers
- Padrino::Admin::Helpers::AuthenticationHelpers
- Padrino::Admin::Helpers::ViewHelpers
- Padrino::Generators
- Padrino::Generators::Admin
- Padrino::Generators::Admin::Actions
- Padrino::Generators::AdminApp
- Padrino::Generators::AdminPage

No matching classes.

# Padrino::Admin::Generators::Orm

Defines the generic ORM management functions used to manipulate data for admin.

### Constants

Column

### Attributes

klass[R]
klass_name[R]
name_param[R]
name_plural[R]
name_singular[R]
orm[R]

### Public Class Methods

new(name, orm, columns=nil, column_fields=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 15
    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 padrino g model #{klass_name}' to create it first?" if @columns.nil? && @klass.nil?
    end

### Public Instance Methods

activerecord?() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 28
    def activerecord?
      case orm
      when :activerecord, :minirecord then true
      else false
      end
    end

all() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 97
    def all
      "#{klass_name}.all"
    end

build(params=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 110
    def build(params=nil)
      if params
        "#{klass_name}.new(#{params})"
      else
        "#{klass_name}.new"
      end
    end

column_fields() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 83
    def column_fields
      excluded_columns = ]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

columns() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 49
    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| ]_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/; 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

destroy() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 134
    def destroy
      case orm
        when :ohm then "#{name_singular}.delete"
        else "#{name_singular}.destroy"
      end
    end

dm_column(p) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 64
    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

field_type(type) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 35
    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

find(params=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 101
    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

find_by_ids(params=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 141
    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

has_error(field) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 163
    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

multiple_destroy(params=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 153
    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

save() click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 118
    def save
      case orm
        when :sequel then "(@#{name_singular}.save rescue false)"
        else "@#{name_singular}.save"
      end
    end

update_attributes(params=nil) click to toggle source

    # File lib/padrino-admin/generators/orm.rb, line 125
    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

[Validate]

Generated with the Darkfish Rdoc Generator 2.