bhf 0.8.0 → 0.8.2

data/lib/bhf/action_view/form_builder.rb

@@ -0,0 +1,36 @@
+module Bhf::ActionView
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    include ActionView::Helpers::FormTagHelper
+
+    def error_label(name, message)
+      label name, "#{object.class.human_attribute_name(name)} #{message}"
+    end
+
+    def field_errors(field)
+      object.errors[field.to_sym]
+    end
+
+    def field_has_errors?(field)
+      field_errors(field).any?
+    end
+
+    def many_to_many_check_box(obj, ref_name, params, hide_label = false, checked = false, bhf_primary_key = nil)
+      mm = :has_and_belongs_to_many
+      bhf_primary_key ||= obj.send(obj.class.bhf_primary_key).to_s
+      unless checked
+        checked = if params[mm] && params[mm][ref_name]
+          params[mm][ref_name][bhf_primary_key] != ''
+        else
+          object.send(ref_name).include?(obj)
+        end
+      end
+      
+      html = hidden_field_tag("#{mm}[#{ref_name}][#{bhf_primary_key}]", '', id: "hidden_#{mm}_#{ref_name}_#{bhf_primary_key}")
+      html = html+' '+check_box_tag("#{mm}[#{ref_name}][#{bhf_primary_key}]", bhf_primary_key, checked)
+      html = html+' '+label_tag("#{mm}_#{ref_name}_#{bhf_primary_key}", obj.to_bhf_s) unless hide_label
+      
+      html
+    end
+
+  end
+end  

data/lib/bhf/action_view/form_options.rb

@@ -0,0 +1,30 @@
+module Bhf::ActionView
+  module FormOptions
+    
+    def option_groups_from_collection_for_select_with_html_attrs(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key, html_attrs)
+      collection.map do |group|
+        option_tags = options_from_collection_for_select_with_html_attrs(
+          group.send(group_method), option_key_method, option_value_method, selected_key, html_attrs)
+
+        content_tag(:optgroup, option_tags, label: group.send(group_label_method))
+      end.join.html_safe
+    end
+    
+    def options_from_collection_for_select_with_html_attrs(collection, value_method, text_method, selected, html_attrs)
+      options = collection.map do |element|
+        [
+          value_for_collection(element, text_method), value_for_collection(element, value_method), option_html_attributes(element), 
+          html_attrs.call(element)
+        ]
+      end
+      selected, disabled = extract_selected_and_disabled(selected)
+      select_deselect = {
+        selected: extract_values_from_collection(collection, value_method, selected),
+        disabled: extract_values_from_collection(collection, value_method, disabled)
+      }
+  
+      options_for_select(options, select_deselect)
+    end
+
+  end
+end

data/lib/bhf/active_record/base.rb

@@ -0,0 +1,58 @@
+module Bhf::ActiveRecord
+  module Base
+
+    extend ActiveSupport::Concern
+    
+    def to_bhf_s
+      return title if self.respond_to? :title
+      return name if self.respond_to? :name
+      return headline if self.respond_to? :headline
+
+      if self.respond_to?(:attributes)
+        return title if attributes['title']
+        return name if attributes['name']
+        klass_name = if self.class.respond_to?(:model_name)
+          self.class.model_name.human
+        else
+          self.class.to_s.humanize
+        end
+        return "#{klass_name} ID: #{send(self.class.primary_key)}" if attributes[self.class.primary_key]
+      end
+
+      self.to_s.humanize
+    end
+
+    module ClassMethods
+      def bhf_default_search(search_params)
+        return self if (search_term = search_params[:text]).blank?
+        where_statement = []
+        columns_hash.each_pair do |name, props|
+          is_number = search_term.to_i.to_s == search_term || search_term.to_f.to_s == search_term
+
+          if props.type == :string || props.type == :text
+            where_statement << "LOWER(#{name}) LIKE LOWER('%#{search_term}%')"
+          elsif props.type == :integer && is_number
+            where_statement << "#{name} = #{search_term.to_i}"
+          elsif props.type == :float && is_number
+            where_statement << "#{name} = #{search_term.to_f}"
+          end
+        end
+
+        where(where_statement.join(' OR '))
+      end
+      
+      def bhf_attribute_method?(column_name)
+        column_names.include?(column_name)
+      end
+      
+      def bhf_primary_key
+        primary_key
+      end
+      
+      def bhf_embedded?
+        false
+      end
+    end
+    
+  end
+end

data/lib/bhf/mongoid/document.rb

@@ -1,165 +1,163 @@
-module Bhf
-  module Mongoid
-    module Document
-      
-      extend ActiveSupport::Concern
+module Bhf::Mongoid
+  module Document
+    
+    extend ActiveSupport::Concern
 
-      class Field
-        attr_reader :type, :name
+    class Field
+      attr_reader :type, :name
 
-        def initialize(mongoid_field)
-          @name = mongoid_field.name
-          @type = mongoid_field.type.to_s.downcase.gsub('mongoid::', '').to_sym
-          @type = :primary_key if @type == :'bson::objectid'
-        end
+      def initialize(mongoid_field)
+        @name = mongoid_field.name
+        @type = mongoid_field.type.to_s.downcase.gsub('mongoid::', '').to_sym
+        @type = :primary_key if @type == :'bson::objectid'
       end
+    end
 
-      class Reflection
-        attr_reader :name, :macro, :klass, :foreign_key
-
-        def initialize(mongoid_field)
-          @name = mongoid_field.name
-          @klass = mongoid_field.class_name.constantize
-          @foreign_key = mongoid_field.key
-          @macro = case mongoid_field.macro
-            when :references_and_referenced_in_many
-              :has_and_belongs_to_many
-            when :references_many
-              :has_many
-            when :references_one
-              :has_one
-            when :referenced_in
-              :belongs_to
-            else
-              mongoid_field.macro
-          end
-        end
-      end
-  
-      def to_bhf_s
-        return title if self.respond_to? :title
-        return name if self.respond_to? :name
-
-        if self.respond_to?(:attributes)
-          return title if attributes['title']
-          return name if attributes['name']
-          klass_name = if self.class.respond_to?(:model_name)
-            self.class.model_name.human
+    class Reflection
+      attr_reader :name, :macro, :klass, :foreign_key
+
+      def initialize(mongoid_field)
+        @name = mongoid_field.name
+        @klass = mongoid_field.class_name.constantize
+        @foreign_key = mongoid_field.key
+        @macro = case mongoid_field.macro
+          when :references_and_referenced_in_many
+            :has_and_belongs_to_many
+          when :references_many
+            :has_many
+          when :references_one
+            :has_one
+          when :referenced_in
+            :belongs_to
           else
-            self.class.to_s.humanize
-          end
-          return "#{klass_name} ID: #{send(self.class.bhf_primary_key)}" if attributes[self.class.bhf_primary_key]
+            mongoid_field.macro
         end
-
-        self.to_s.humanize
       end
+    end
 
-      module ClassMethods
-        def columns_hash
-          c = {}
-          fields.each_pair do |key, meta|
-            next if meta.options[:metadata]
-            next if key == '_type'
-            c[key] = Field.new(meta)
-          end
-          c
-        end
-        
-        def reflections
-          c = {}
-          relations.each do |key, meta|
-            next if meta.macro == :embedded_in
-            c[key.to_sym] = Reflection.new(meta)
-          end
-          c
-        end
-        
-        def bhf_attribute_method?(column_name)
-          attribute_method?(column_name)
-        end
-        
-        def bhf_primary_key
-          '_id'
+    def to_bhf_s
+      return title if self.respond_to? :title
+      return name if self.respond_to? :name
+
+      if self.respond_to?(:attributes)
+        return title if attributes['title']
+        return name if attributes['name']
+        klass_name = if self.class.respond_to?(:model_name)
+          self.class.model_name.human
+        else
+          self.class.to_s.humanize
         end
-        
-        def order(a)
-          order_by(a)
+        return "#{klass_name} ID: #{send(self.class.bhf_primary_key)}" if attributes[self.class.bhf_primary_key]
+      end
+
+      self.to_s.humanize
+    end
+
+    module ClassMethods
+      def columns_hash
+        c = {}
+        fields.each_pair do |key, meta|
+          next if meta.options[:metadata]
+          next if key == '_type'
+          c[key] = Field.new(meta)
         end
-        
-        def reorder(a)
-          order_by(a)
+        c
+      end
+      
+      def reflections
+        c = {}
+        relations.each do |key, meta|
+          next if meta.macro == :embedded_in
+          c[key.to_sym] = Reflection.new(meta)
         end
-        
-        def bhf_default_search(search_params)
-          return self if (search_term = search_params[:text]).blank?
-
-          arr = []
-          columns_hash.each_pair do |column, props|
-            is_number = search_term.to_i.to_s == search_term || search_term.to_f.to_s == search_term
-
-            if props.type == :primary_key
-              arr << {props.name.to_sym => search_term}
-            elsif props.type == :string || props.type == :text
-              arr << {props.name.to_sym => /#{search_term}/i}
-            elsif props.type == :integer && is_number
-              arr << {props.name.to_sym => search_term.to_i}
-            elsif props.type == :float && is_number
-              arr << {props.name.to_sym => search_term.to_f}
-            end
+        c
+      end
+      
+      def bhf_attribute_method?(column_name)
+        attribute_method?(column_name)
+      end
+      
+      def bhf_primary_key
+        '_id'
+      end
+      
+      def order(a)
+        order_by(a)
+      end
+      
+      def reorder(a)
+        order_by(a)
+      end
+      
+      def bhf_default_search(search_params)
+        return self if (search_term = search_params[:text]).blank?
 
-          end
-          self.or(arr)
-        end
+        arr = []
+        columns_hash.each_pair do |column, props|
+          is_number = search_term.to_i.to_s == search_term || search_term.to_f.to_s == search_term
 
-        def get_embedded_parent(parent_id, &block)
-          relations.each do |key, meta|
-            next unless meta.macro == :embedded_in
-            parent = meta.class_name.constantize
-            parent = parent.find(parent_id) rescue nil
-            
-            if parent
-              return block.call(parent, meta) if block_given?
-              return parent
-            end
+          if props.type == :primary_key
+            arr << {props.name.to_sym => search_term}
+          elsif props.type == :string || props.type == :text
+            arr << {props.name.to_sym => /#{search_term}/i}
+          elsif props.type == :integer && is_number
+            arr << {props.name.to_sym => search_term.to_i}
+          elsif props.type == :float && is_number
+            arr << {props.name.to_sym => search_term.to_f}
           end
+
         end
+        self.or(arr)
+      end
 
-        def bhf_new_embed(parent_id, params = nil)
-          get_embedded_parent parent_id do |parent, meta|
-            key_name = if meta.inverse_of?
-              meta.inverse_of
-            else
-              meta.inverse_foreign_key.pluralize
-            end.to_s
-            if parent.relations[key_name] and parent.relations[key_name].macro == :embeds_one
-              parent.send("build_#{key_name}", params)
-            else
-              parent.send(key_name).build(params)
-            end
+      def get_embedded_parent(parent_id, &block)
+        relations.each do |key, meta|
+          next unless meta.macro == :embedded_in
+          parent = meta.class_name.constantize
+          parent = parent.find(parent_id) rescue nil
+          
+          if parent
+            return block.call(parent, meta) if block_given?
+            return parent
           end
         end
+      end
 
-        def bhf_find_embed(parent_id, ref_id)
-          get_embedded_parent parent_id do |parent, meta|
-            key_name = if meta.inverse_of?
-              meta.inverse_of
-            else
-              meta.inverse_foreign_key.pluralize
-            end.to_s
-            relation = parent.send(key_name)
-            if parent.relations[key_name].macro == :embeds_one
-              relation
-            else
-              relation.find(ref_id)
-            end
+      def bhf_new_embed(parent_id, params = nil)
+        get_embedded_parent parent_id do |parent, meta|
+          key_name = if meta.inverse_of?
+            meta.inverse_of
+          else
+            meta.inverse_foreign_key.pluralize
+          end.to_s
+          if parent.relations[key_name] and parent.relations[key_name].macro == :embeds_one
+            parent.send("build_#{key_name}", params)
+          else
+            parent.send(key_name).build(params)
           end
         end
+      end
 
-        def bhf_embedded?
-          embedded?
+      def bhf_find_embed(parent_id, ref_id)
+        get_embedded_parent parent_id do |parent, meta|
+          key_name = if meta.inverse_of?
+            meta.inverse_of
+          else
+            meta.inverse_foreign_key.pluralize
+          end.to_s
+          relation = parent.send(key_name)
+          if parent.relations[key_name].macro == :embeds_one
+            relation
+          else
+            relation.find(ref_id)
+          end
         end
       end
 
+      def bhf_embedded?
+        embedded?
+      end
     end
+
   end
 end

data/lib/bhf/platform/attribute/abstract.rb

@@ -0,0 +1,52 @@
+module Bhf::Platform::Attribute
+  class Abstract
+    
+    attr_reader :name, :title, :info
+    
+    def initialize(options)
+      @name = options[:name]
+      @title = options[:title]
+      @info = options[:info]
+      
+      @options_form_type = options[:form_type].to_sym if options[:form_type]
+      @options_display_type = options[:display_type].to_sym if options[:display_type]
+      @options_show_type = options[:show_type].to_sym if options[:show_type]
+      
+      @link_platform_settings = options[:link] unless options[:link].blank?
+    end
+    
+    def macro
+      :column
+    end
+    
+    def form_type
+      @options_form_type || @name
+    end
+    
+    def display_type
+      @options_display_type || @name
+    end
+    
+    def show_type
+      @options_show_type || display_type || @name
+    end
+    
+    def link
+      return unless @link_platform_settings
+      @link ||= Bhf::Platform::Base.new(@link_platform_settings)
+    end
+    
+    def reflection
+      false
+    end
+
+    def db_name
+      name
+    end
+    
+    def reorderble
+      false
+    end
+
+  end
+end