rear 0.2.0

data/lib/rear/templates/pane/select.slim

@@ -0,0 +1,5 @@
+div *attrs(column, :pane)
+  - options.each_pair do |k,v|
+    - if active_options.include?(k)
+      = v
+      br

data/lib/rear/templates/pane/string.slim

@@ -0,0 +1,2 @@
+div *attrs(column, :pane)
+  = value

data/lib/rear/templates/pane/text.slim

@@ -0,0 +1,2 @@
+div *attrs(column, :pane)
+  = value

data/lib/rear/templates/pane/time.slim

@@ -0,0 +1,2 @@
+div *attrs(column, :pane)
+  = value.kind_of?(Time) ? value.strftime('%H:%M:%S') : value

data/lib/rear/utils.rb

@@ -0,0 +1,288 @@
+module RearUtils
+  include RearConstants
+  
+  # just define controller, do not set model
+  def initialize_model_controller model
+    return model.const_get(:RearController) if model.const_defined?(:RearController)
+    ctrl = model.const_set(:RearController, Class.new(E))
+    RearControllerSetup.init(ctrl)
+    ctrl.map EUtils.class_to_route(model)
+    ctrl.model model
+    ctrl
+  end
+  module_function :initialize_model_controller
+
+  def associated_model_controller model, ensure_mounted = false
+    ctrl = ObjectSpace.each_object(Class).find do |o|
+      EUtils.is_app?(o) && o.respond_to?(:model) && o.model == model
+    end
+    unless ctrl
+      ctrl = initialize_model_controller(model)
+      ctrl.label(false) # automatically generated controllers not shown in menu
+    end
+    ctrl.mounted? || ctrl.mount if ensure_mounted
+    ctrl
+  end
+  module_function :associated_model_controller
+
+  def extract_assocs model, *args
+    send('extract_%s_assocs' % orm(model), model, *args)
+  end
+  module_function :extract_assocs
+
+  def extract_associated_ar_model model, assoc
+    class_name = assoc.options[:class_name] ||
+      ActiveSupport::Inflector.camelize(ActiveSupport::Inflector.singularize(assoc.name.to_s))
+    if (ns = class_name.to_s.split('::')).size > 1
+      return ns.inject(Object) {|n,c| n.const_get c}
+    else
+      if (ns = model.name.split('::')).size > 1
+        ns.pop
+        model_namespace = ns.inject(Object) {|n,c| n.const_get c}
+      else
+        model_namespace = Object
+      end
+      return model_namespace.const_get(class_name)
+    end
+    nil
+  end
+  module_function :extract_associated_ar_model
+
+  def extract_ar_assocs model, any = false
+    model.reflect_on_all_associations.inject(ASSOCS__STRUCT.call) do |map, r|
+      
+      target_model = extract_associated_ar_model(model, r) ||
+        raise(NameError, "Was unable to detect model for %s relation" % r)
+
+      target_pkey = r.options[:primary_key] || target_model.primary_key
+      if any || target_pkey  # models without primary key not handled by default
+        
+        target_pkey = target_pkey.to_sym if target_pkey
+        readonly = nil
+        belongs_to_keys = {source: nil, target: nil}
+
+        assoc_type = case r.macro
+        when :belongs_to
+          belongs_to_keys[:source] = (r.options[:foreign_key] || ActiveSupport::Inflector.foreign_key(r.name)).to_sym
+          belongs_to_keys[:target] = target_pkey
+          :belongs_to
+        when :has_one
+          readonly = true if r.options[:through]
+          :has_one
+        else
+          :has_many
+        end
+
+        map[assoc_type].update r.name => {
+                  type: assoc_type,
+                  name: r.name,
+          remote_model: target_model,
+           remote_pkey: target_pkey,
+              readonly: readonly,
+                dom_id: dom_id_generator(model, assoc_type, r.name),
+          belongs_to_keys: belongs_to_keys
+        }.freeze
+      end
+      map
+    end.freeze
+  end
+  module_function :extract_ar_assocs
+
+  def extract_dm_assocs model, any = false
+    model.relationships.entries.inject(ASSOCS__STRUCT.call) do |map, r|
+      _, target_pkey = extract_dm_columns(r.target_model)
+      if any || target_pkey # only models with a primary key are handled by default
+
+        readonly = nil
+        belongs_to_keys = {source: nil, target: nil}
+
+        assoc_type = case r.class.name.split('::')[2]
+        when 'ManyToOne'
+          belongs_to_keys[:source] = r.source_key.first.name.to_sym
+          belongs_to_keys[:target] = r.target_key.first.name.to_sym
+          :belongs_to
+        when 'OneToOne'
+          readonly = true if r.options[:through]
+          :has_one
+        else
+          :has_many
+        end
+
+        map[assoc_type].update r.name => {
+                  type: assoc_type,
+                  name: r.name,
+          remote_model: r.target_model,
+           remote_pkey: target_pkey,
+              readonly: readonly,
+                dom_id: dom_id_generator(model, assoc_type, r.name),
+          belongs_to_keys: belongs_to_keys
+        }.freeze
+      end
+      map
+    end.freeze
+  end
+  module_function :extract_dm_assocs
+
+  def extract_sq_assocs model, any = false
+    model.associations.inject(ASSOCS__STRUCT.call) do |map,an|
+      a = model.association_reflection(an)
+      
+      target_model = extract_constant(a[:class_name])
+      _, target_pkey = extract_sq_columns(target_model)
+      
+      if any || target_pkey # only models with a primary key are handled by default
+        readonly = nil
+        belongs_to_keys = {source: nil, target: nil}
+
+        assoc_type = case a[:type]
+        when :many_to_one
+          belongs_to_keys[:source] = a[:key]
+          belongs_to_keys[:target] = a[:primary_key] || target_pkey
+          :belongs_to
+        when :one_to_one
+          readonly = true if a[:through]
+          :has_one
+        else
+          :has_many
+        end
+
+        map[assoc_type].update a[:name] => {
+                  type: assoc_type,
+                  name: a[:name],
+          remote_model: target_model,
+           remote_pkey: target_pkey,
+              readonly: readonly,
+                dom_id: dom_id_generator(model, assoc_type, a[:name]),
+            belongs_to_keys: belongs_to_keys
+        }.freeze
+      end
+      map
+    end.freeze
+  end
+  module_function :extract_sq_assocs
+
+  def extract_columns model
+    send('extract_%s_columns' % orm(model), model)
+  end
+  module_function :extract_columns
+
+  def extract_ar_columns model
+    unless model.table_exists?
+      puts "WARN: %s table does not exists!" % model.table_name
+      return [[], :id]
+    end
+    pkey = nil
+    columns = model.columns.inject([]) do |f,c|
+      name, type = c.name.to_sym, c.type.to_s.downcase.to_sym
+      type = COLUMNS__DEFAULT_TYPE unless COLUMNS__HANDLED_TYPES.include?(type)
+      (c.primary && pkey = name) ? f : f << [name, type]
+    end
+    [columns.freeze, pkey]
+  end
+  module_function :extract_ar_columns
+
+  def extract_dm_columns model
+    pkey = nil
+    # TODO: find a way to handle Enum columns
+    columns = model.properties.inject([]) do |f,c|
+      name, type = c.name.to_sym, c.class.name.to_s.split('::').last.downcase.to_sym
+      type = COLUMNS__DEFAULT_TYPE unless [:serial].concat(COLUMNS__HANDLED_TYPES).include?(type)
+      (type == :serial && pkey = name) ? f : f << [name, type]
+    end
+    [columns.freeze, pkey]
+  end
+  module_function :extract_dm_columns
+
+  def extract_sq_columns model
+    pkey = nil
+    columns = model.db_schema.inject([]) do |map,(n,s)|
+      if s[:primary_key]
+        pkey = n
+        map
+      else
+        type = s[:db_type].to_s.split(/\W/).first.to_s.downcase.to_sym
+        unless COLUMNS__HANDLED_TYPES.include?(type)
+          type = s[:type].to_s.downcase.to_sym
+          unless COLUMNS__HANDLED_TYPES.include?(type)
+            type = COLUMNS__DEFAULT_TYPE
+          end
+        end
+        map << [n, type]
+      end
+    end
+    [columns.freeze, pkey]
+  end
+  module_function :extract_sq_columns
+
+  def quote_column model, column
+    send('quote_%s_column' % orm(model), model, column)
+  end
+  module_function :quote_column
+
+  def quote_ar_column model, column
+    model.connection.quote_column_name(column)
+  end
+  module_function :quote_ar_column
+
+  def quote_dm_column model, column
+    property = model.properties.find {|p| p.name == column}
+    model.repository(model.repository_name).adapter.property_to_column_name(property, false)
+  end
+  module_function :quote_dm_column
+
+  def quote_sq_column model, column
+    model.db.quote_identifier(column)
+  end
+  module_function :quote_sq_column
+
+  def ar? model
+    [:connection, :columns, :reflect_on_all_associations].all? do |m|
+      model.respond_to?(m)
+    end
+  end
+  module_function :ar?
+
+  def dm? model
+    [:repository, :properties, :relationships].all? do |m|
+      model.respond_to?(m)
+    end
+  end
+  module_function :dm?
+
+  def sq? model
+    [:db_schema, :columns, :dataset, :associations].all? do |m|
+      model.respond_to?(m)
+    end
+  end
+  module_function :sq?
+
+  def orm model
+    [:ar, :dm, :sq].find {|o| send('%s?' % o, model)}
+  end
+  alias is_orm? orm
+  module_function :orm
+  module_function :is_orm?
+
+  def number_with_delimiter n
+    n.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, '\1,')
+  end
+  module_function :number_with_delimiter
+
+  def normalize_html_attrs attrs
+    (attrs||{}).inject({}) {|h,(k,v)| h.merge k.to_s.downcase => v}
+  end
+  module_function :normalize_html_attrs
+
+  def dom_id_generator *args
+    (args + [args.__id__]).flatten.join('__').gsub(/\W+/, '')
+  end
+  module_function :dom_id_generator
+
+  def extract_constant smth
+    return Object.const_get(smth) if smth.is_a?(Symbol)
+    return smth.sub('::', '').split('::').inject(Object) {|o,c| o.const_get(c)} if smth.is_a?(String)
+    smth
+  end
+  module_function :extract_constant
+
+end

data/rear.gemspec

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+version = '0.2.0'
+Gem::Specification.new do |s|
+
+  s.name = 'rear'
+  s.version = version
+  s.authors = ['Silviu Rusu']
+  s.email = ['slivuz@gmail.com']
+  s.homepage = 'https://github.com/espresso/rear'
+  s.summary = 'rear-%s' % version
+  s.description = 'ORM-agnostic CRUDifier for Espresso Framework'
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'e',    '>= 0.4.8'
+  s.add_dependency 'el',   '>= 0.4.8'
+  s.add_dependency 'slim', '>= 2.0'
+
+  s.add_development_dependency 'bundler'
+
+  s.require_paths = ['lib']
+  s.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock)\Z/}
+  s.executables = ['rear']
+  
+  s.licenses = ['MIT']
+end

data/test/helpers.rb

@@ -0,0 +1,33 @@
+module EASpecHelpers
+  
+  def new_book data = {}
+    data = {name: random_string, about: random_string}.merge(data)
+    item = Book.create(data)
+    item_id = item[:id].to_i
+    check(item_id) > 0
+    [item, item_id]
+  end
+
+  def count_books conditions = nil
+    args = conditions ? [{conditions: conditions}] : []
+    RearORM.new(Book).count *args
+  end
+
+  def extract_elements selector = nil
+    selector ||= last_request.env['PATH_INFO'] =~ /\/+edit\/+\d+/ ? 
+      '.editor-column_value' : '.pane-column_value'
+    doc = Nokogiri::HTML(last_response.body)
+    columns = doc.css(selector)
+    columns
+  end
+
+  def readonly_error? last_response
+    is(last_response).client_error?
+    does(last_response.body) =~ /readonly/i
+  end
+
+  def random_string
+    ('A'..'Z').to_a.sample(5).join + [rand.to_s, rand.to_s].sample
+  end
+  
+end

data/test/models/ar.rb

@@ -0,0 +1,52 @@
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+
+class Author < ActiveRecord::Base
+end
+
+class Genre < ActiveRecord::Base
+end
+
+class Book < ActiveRecord::Base
+  belongs_to :author
+  has_and_belongs_to_many :genres
+end
+
+class State < ActiveRecord::Base
+  has_many :cities, foreign_key: :state_code, primary_key: :code
+end
+
+class City < ActiveRecord::Base
+  belongs_to :state, foreign_key: :state_code, primary_key: :code
+end
+
+ActiveRecord::Migration.create_table :books_genres do |t|
+  t.integer :book_id
+  t.integer :genre_id
+end
+
+ActiveRecord::Migration.create_table :genres do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :authors do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :books do |t|
+  t.integer :author_id
+  t.string  :name
+  t.text    :about
+  t.string  :cover
+  t.string  :colors
+  t.date    :created_at
+end
+
+ActiveRecord::Migration.create_table :states do |t|
+  t.string :name
+  t.string :code
+end
+
+ActiveRecord::Migration.create_table :cities do |t|
+  t.string :name
+  t.string :state_code
+end

data/test/models/dm.rb

@@ -0,0 +1,53 @@
+DataMapper.setup :default, 'sqlite::memory:'
+
+class Author
+  include DataMapper::Resource
+
+  property :id,    Serial
+  property :name,  String
+end
+
+class Genre
+  include DataMapper::Resource
+
+  property :id,    Serial
+  property :name,  String
+
+  has n, :books, through: Resource
+end
+
+class Book
+  include DataMapper::Resource
+
+  property :id,     Serial
+  property :name,   String
+  property :about,  Text
+  property :cover,  String
+  property :colors, String
+  property :created_at, Date
+
+  belongs_to :author, required: false
+  has n,     :genres, through:  Resource
+end
+
+class State
+  include DataMapper::Resource
+  
+  property :id, Serial
+  property :name, String, index: true
+  property :code, String, unique: true, length: 2
+
+  has n, :cities, child_key: :state_code, parent_key: :code
+end
+
+class City
+  include DataMapper::Resource
+  
+  property :id, Serial
+  property :name, String, index: true
+
+  belongs_to :state, child_key: :state_code, parent_key: :code, required: false
+end
+
+DataMapper.finalize
+DataMapper.auto_migrate!