clevic 0.12.0 → 0.13.0.b1

data/lib/clevic/record.rb

@@ -3,32 +3,22 @@ require 'clevic/default_view.rb'
 
 module Clevic
 
-  # include this in ActiveRecord::Base instances to
+  # include this in Sequel::Model classes to
   # get embedded view definitions. See ModelBuilder.
   #
   # A Clevic::Default#{model}View class will be created. If
   # a define_ui block is not specified in the entity class, 
   # a default UI will be created.
   module Record
-    # TODO not sure if these are necessary here anymore?
-    def self.db_options=( db_options )
-      @db_options = db_options
-    end
-    
-    def self.db_options
-      @db_options
-    end
-    
     module ClassMethods
       def default_view_class_name
         "::Clevic::Default#{name.gsub('::','')}View"
       end
       
-      #TODO will have to fix modules here
       def create_view_class
         # create the default view class
         # Don't use Class.new because even if you assign
-        # the result to a contstant, there are still anonymous classes
+        # the result to a constant, there are still anonymous classes
         # hanging around, which gives weird results with Clevic::View.subclasses.
         st,line = <<-EOF, __LINE__
           class #{default_view_class_name} < Clevic::DefaultView
@@ -60,11 +50,6 @@ module Clevic
       
       # create the default view class
       base.create_view_class
-
-      # DbOptions instance
-      db_options = nil
-      found = ObjectSpace.each_object( Clevic::DbOptions ){|x| db_options = x}
-      @db_options = db_options
     end
   end
   

data/lib/clevic/sampler.rb

@@ -0,0 +1,81 @@
+require 'clevic/generic_format.rb'
+require 'andand'
+
+module Clevic
+
+# Calculate a string sample for a particular Field
+class Sampler
+  def initialize( entity_class, field_name, display, &block )
+    @entity_class = entity_class
+    @field_name = field_name
+    @display = display
+    @format_block = block
+  end
+  
+  attr_reader :entity_class, :field_name, :display
+  
+  def meta
+    @meta ||= entity_class.meta[field_name]
+  end
+  
+  # return a string which is representative of the width of the field
+  def compute
+    case meta.type
+    when :string, :text
+      string_sample
+    
+    when :date, :time, :datetime, :timestamp
+      date_time_sample
+    
+    when :numeric, :decimal, :integer, :float
+      numeric_sample
+    
+    # TODO return a width, or something like that
+    when :boolean; 'W'
+    
+    when :many_to_one
+      related_sample
+    
+    else
+      if meta.type != NilClass
+        raise "Sampler#compute can't figure out sample for #{entity_class.name}.#{field_name} because it's a #{meta.type.inspect}"
+      end
+    
+    end
+  end
+  
+  def do_format( value )
+    @format_block.call( value )
+  end
+  
+  # default to max length of 20
+  def string_sample
+    'N' * ( entity_class.max( :length.sql_function( field_name ) ).andand.to_i || 20 )
+  end
+  
+  def date_time_sample
+    sample_date = entity_class \
+      .filter( ~{ field_name => nil } ) \
+      .select( field_name ) \
+      .limit(1) \
+      .single_value
+    ;
+    # replace all letters with 'N'
+    do_format( sample_date || Date.today ).gsub( /[[:alpha:]]/, 'N' )
+  end
+  
+  def numeric_sample
+    max = entity_class.max( field_name )
+    min = entity_class.min( field_name )
+    max_length = [ do_format( min ).to_s, do_format( max ).to_s ].map( &:length ).max
+    '9' * ( max_length || 5 )
+  end
+  
+  def related_sample
+    if display.respond_to?( :to_sym )
+      Sampler.new( eval( meta.class_name ), display.to_sym, nil, &@format_block ).compute
+    end
+  end
+end
+
+end

data/lib/clevic/sequel_ar_adapter.rb

@@ -0,0 +1,215 @@
+require 'sequel'
+
+# remove dependency on this and active_support unless they're really needed
+require 'clevic/ar_methods.rb'
+require 'clevic/attribute_list.rb'
+
+module Clevic
+  class SequelAdaptor
+    def initialize( entity_class )
+      @entity_class = entity_class
+      @entity_class.plugin :ar_methods
+    end
+    
+    def quoted_false
+      @entity_class.dataset.boolean_constant_sql( false )
+    end
+    
+    def quoted_true
+      @entity_class.dataset.boolean_constant_sql( true )
+    end
+    
+    def count( *args )
+      @entity_class.count_ar( *args )
+    end
+    
+    def find( *args )
+      @entity_class.find_ar( *args )
+    end
+    
+    def attribute_list( attribute, attribute_value, by_description, by_frequency, find_options, &block )
+      lister = AttributeList.new( @entity_class, attribute, attribute_value, find_options )
+      ds = lister.dataset( by_description, by_frequency )
+      ds.map( &block )
+    end
+  end
+  
+  class ActiveRecordAdaptor
+    def initialize( entity_class )
+      @entity_class = entity_class
+    end
+    
+    def quoted_false
+      @entity_class.connection.quoted_false
+    end
+    
+    def quoted_true
+      @entity_class.connection.quoted_true
+    end
+    
+    # options is a hash
+    def count( attribute = nil, options = {} )
+      @entity_class.count( attribute, options )
+    end
+    
+    def find( options )
+      @entity_class.find( :all, options )
+    end
+
+    def query_order_description( attribute, attribute_value, find_options )
+      <<-EOF
+        select distinct #{attribute.to_s}, lower(#{attribute.to_s})
+        from #{@entity_class.table_name}
+        where (#{find_options[:conditions] || '1=1'})
+        or #{@entity_class.connection.quote_column_name( attribute.to_s )} = #{@entity_class.connection.quote( attribute_value )}
+        order by lower(#{attribute.to_s})
+      EOF
+    end
+    
+    def query_order_frequency( attribute, attribute_value, find_options )
+      <<-EOF
+        select distinct #{attribute.to_s}, count(#{attribute.to_s})
+        from #{entity_class.table_name}
+        where (#{find_options[:conditions] || '1=1'})
+        or #{@entity_class.connection.quote_column_name( attribute.to_s )} = #{@entity_class.connection.quote( attribute_value )}
+        group by #{attribute.to_s}
+        order by count(#{attribute.to_s}) desc
+      EOF
+    end
+    
+    # values are passed as row objects to block
+    def attribute_list( attribute, attribute_value, by_description, by_frequency, find_options, &block )
+      query =
+      case
+        when by_description
+          entity_class.adaptor.query_order_description( attribute, attribute_value, find_options )
+        when by_frequency
+          entity_class.adaptor.query_order_frequency( attribute, attribute_value, find_options )
+        else
+          entity_class.adaptor.query_order_frequency( attribute, attribute_value, find_options )
+      end
+        
+      entity_class.connection.execute( query ).each( &block )
+    end
+  end
+end
+
+if defined? ActiveRecord
+  module ActiveRecord
+    class Base
+      # checks to see if attribute_sym is either in the column
+      # name list, or in the set of reflections.
+      def self.has_attribute?( attribute_sym )
+        if column_names.include?(  attribute_sym.to_s )
+          true
+        elsif reflections.has_key?(  attribute_sym )
+          true
+        else
+          false
+        end
+      end
+      
+      def self.attribute_names
+        ( column_names + reflections.keys.map {|sym| sym.to_s} ).sort
+      end
+      
+      def adaptor
+        @adaptor ||= Clevic::ActiveRecordAdaptor.new( self )
+      end
+    end
+  end
+end
+
+module Sequel
+  class Model
+    class << self
+      def translate_options( options )
+        options[:key] = options[:foreign_key].andand.to_sym
+        options.delete( :foreign_key )
+        
+        options[:class] = options[:class_name].andand.to_sym
+        options.delete( :class_name )
+        options
+      end
+      
+      def belongs_to( name, options = nil, &block )
+        # work around possible Sequel bug
+        if options.nil?
+          many_to_one( name, &block )
+        else
+          many_to_one( name, translate_options( options ), &block )
+        end
+      end
+      
+      def has_many( name, options = nil, &block )
+        # work around possible Sequel bug
+        if options.nil?
+          one_to_many( name, &block )
+        else
+          one_to_many( name, translate_options( options ), &block )
+        end
+      end
+      
+      def table_exists?
+        db.table_exists?( implicit_table_name )
+      end
+      
+      def column_names
+        columns
+      end
+      
+      def reflections
+        association_reflections 
+      end
+      
+      def has_attribute?( attribute )
+        column_names.include?( attribute )
+      end
+      
+      def attribute_names
+        columns
+      end
+      
+      def columns_hash
+        db_schema
+      end
+      
+      # return a class containing various db methods. Not sure
+      # if this is the right way to do it, but at least this way
+      # the model class namespace doesn't get filled up with crud
+      def adaptor
+        @adaptor ||= Clevic::SequelAdaptor.new( self )
+      end
+    end
+    
+    def readonly?
+      false
+    end
+    
+    def changed?
+      modified?
+    end
+    
+    def new_record?; new?; end
+    
+    class Errors
+      def invalid?( field_name )
+        self.has_key?( field_name )
+      end
+    end
+    
+    module Associations
+      class ManyToOneAssociationReflection
+        # return class for this side of the association
+        def class_name
+          self[:class_name]
+        end
+        
+        # return class for the other side of the association
+        def klass
+          eval class_name
+        end
+      end
+    end
+  end
+end

data/lib/clevic/sequel_length_validation.rb

@@ -0,0 +1,23 @@
+require 'sequel'
+
+=begin
+This validates that strings going into varchar fields display meaningful
+warnings instead of incomprenensible native RDBMS errors.
+=end
+
+class Sequel::Model
+  def self.varchar_columns
+    @varchar_columns ||= columns.select do |col|
+      db_type = db_schema[col][:db_type]
+      db_type =~ /var/ && db_type =~ /char/
+    end
+  end
+
+  def validate
+    super
+    self.class.varchar_columns.each do |column|
+      limit = self.class.meta[column].limit
+      errors.add( column, "is longer than #{limit}" ) if self[column] && self[column].length > limit
+    end
+  end
+end

data/lib/clevic/sequel_meta.rb

@@ -0,0 +1,65 @@
+require 'sequel'
+require 'clevic/model_column.rb'
+
+module Sequel
+  module Plugins
+    module Meta
+      # plugin :meta calls this.
+      # model is the model class. The rest is whatever options are
+      # in the plugin call
+      #  plugin :meta
+      def self.configure(model, options = {})
+        model.instance_eval do
+          # store model-related stuff here
+        end
+      end
+      
+      module ClassMethods
+        # Copy the necessary class instance variables to the subclass.
+        def inherited(subclass)
+          super
+          #~ store = @cache_store
+          #~ ttl = @cache_ttl
+          #~ cache_ignore_exceptions = @cache_ignore_exceptions
+          #~ subclass.instance_eval do
+            #~ @cache_store = store
+            #~ @cache_ttl = ttl
+            #~ @cache_ignore_exceptions = cache_ignore_exceptions
+          #~ end
+        end
+        
+        def meta
+          if @meta.nil?
+            @meta = {}
+            db_schema.each do |key,value|
+              @meta[key] = ModelColumn.new( key, value.merge( :association => false ) )
+            end
+            
+            association_reflections.each do |key,value|
+              @meta[key] = ModelColumn.new( key, value.merge( :association => true ) )
+            end
+          end
+          @meta
+        end
+        
+        # reload from current metadata
+        def meta!
+          @meta = nil
+          meta
+        end
+        
+        # column and relations, but not keys for defined relations
+        def attributes
+          meta.reject do |column,model_column|
+            meta.values.map( &:keys ).include?( [ column ] )
+          end
+        end
+      end
+      
+      module InstanceMethods
+      end
+    end
+  end
+end
+
+Sequel::Model.plugin :meta

data/lib/clevic/sequel_naked.rb

@@ -0,0 +1,30 @@
+require 'sequel'
+
+module Sequel
+  module Plugins
+    # Fix the naked call to do the following:
+    # - remove the row_proc
+    # - remove the model method, or make it return nil
+    # - fix the destroy method. Not sure what this means right now.
+    module Naked
+      def self.configure(model, options = {})
+        model.instance_eval do
+          # store model-related stuff here
+        end
+      end
+      
+      module ClassMethods
+        def inherited(subclass)
+          super
+        end
+        
+        def naked( *args )
+          
+        end
+      end
+      
+      module InstanceMethods
+      end
+    end
+  end
+end