cowtech-rails 1.9.7.6 → 2.0.0.0

data/app/helpers/cowtech/ruby_on_rails/helpers/{crud_helper.rb → ar_crud_helper.rb}

@@ -7,7 +7,7 @@
 module Cowtech
   module RubyOnRails
     module Helpers
-      module CRUDHelper
+      module ArCrudHelper
         attr_reader :data_bounds
         attr_reader :record
 

data/app/helpers/cowtech/ruby_on_rails/helpers/browser_helper.rb

@@ -9,33 +9,36 @@ module Cowtech
     module Helpers
       module BrowserHelper
         def browser_detect
-          rv = {:engine => :unknown, :version => "0", :platform => :unknown, :agent => request.user_agent || request.env['HTTP_USER_AGENT'].downcase || ""}
-          agent = rv[:agent].downcase
+          rv = {:engine => :unknown, :version => "0", :platform => :unknown, :agent => request.user_agent || request.env['HTTP_USER_AGENT'].try(:downcase) || ""}
+          
+          if rv[:agent].present? then
+            agent = rv[:agent].downcase
 
-          # Identify engine
-          if agent =~ /opera/ then
-            rv[:engine] = :opera
-          elsif agent =~ /webkit/ then
-            rv[:engine] = (agent =~ /chrome|chromium/ ? :chrome : :safari)
-          elsif agent =~ /msie/ || agent =~ /webtv/ then
-            rv[:engine] = :msie
-          elsif agent =~ /mozilla/ && agent !~ /compatible/ then
-            rv[:engine] = :mozilla
-          end
+            # Identify engine
+            if agent =~ /opera/ then
+              rv[:engine] = :opera
+            elsif agent =~ /webkit/ then
+              rv[:engine] = (agent =~ /chrome|chromium/ ? :chrome : :safari)
+            elsif agent =~ /msie/ || agent =~ /webtv/ then
+              rv[:engine] = :msie
+            elsif agent =~ /mozilla/ && agent !~ /compatible/ then
+              rv[:engine] = :mozilla
+            end
 
-          # Identify version
-          rv[:version] = $1 if agent =~ /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/
-          rv[:version_number] = rv[:version].to_f
+            # Identify version
+            rv[:version] = $1 if agent =~ /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/
+            rv[:version_number] = rv[:version].to_f
 
-          # Identify platform
-          if agent =~ /linux/
-            rv[:platform] = :linux
-          elsif agent =~ /macintosh|mac os x/ then
-            rv[:platform] = :mac
-          elsif agent =~ /windows|win32|win64/ then
-            rv[:platform] = :windows
+            # Identify platform
+            if agent =~ /linux/
+              rv[:platform] = :linux
+            elsif agent =~ /macintosh|mac os x/ then
+              rv[:platform] = :mac
+            elsif agent =~ /windows|win32|win64/ then
+              rv[:platform] = :windows
+            end
           end
-
+          
           @browser = rv
         end
 

data/app/helpers/cowtech/ruby_on_rails/helpers/mongoid_crud_helper.rb

@@ -0,0 +1,226 @@
+# encoding: utf-8
+#
+# This file is part of the cowtech-rails gem. Copyright (C) 2011 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Cowtech
+  module RubyOnRails
+    module Helpers
+      module MongoidCrudHelper
+        attr_accessor :mongo_class
+        attr_accessor :records
+        attr_accessor :mongo_sort_order
+        attr_accessor :mongo_bounds
+        attr_accessor :mongo_query
+        attr_accessor :mongo_records
+        attr_accessor :mongo_pager
+  
+        def mongo_setup(args = {})
+          @mongo_class = args[:class] if args[:class]
+          @mongo_class = @mongo_class.constantize if @mongo_class.is_a?(String)
+          @mongo_records = []
+          @mongo_sort_order = [[:_id, :asc]]
+          @mongo_bounds = {:total => 0, :first => 1, :last => 0, :pages => 1, :page => 1, :per_page => 1}
+          @mongo_query = self.mongo_reset_query(:also_deleted => args[:also_deleted]) if @mongo_class
+        end
+
+        def mongo_has_data?(args = {})
+          @mongo_bounds[:total] > 0
+        end
+
+        def mongo_calculate_bounds(args = {})
+          if @mongo_records.present? then
+            @mongo_bounds[:total] = @mongo_records.count
+            @mongo_bounds[:per_page] = (args[:per_page].is_integer? ? args[:per_page] : @mongo_records.first.class.per_page).to_integer
+            @mongo_bounds[:pages] = (@mongo_bounds[:total].to_f / @mongo_bounds[:per_page]).ceil
+
+            if @mongo_bounds[:per_page] > 0 then
+              @mongo_bounds[:page] = self.mongo_get_page_param(:upperbound => @mongo_bounds[:pages])
+              base = ((@mongo_bounds[:page] - 1) * @mongo_bounds[:per_page])
+              @mongo_bounds[:first] = base + 1
+              @mongo_bounds[:last] = [base + @mongo_bounds[:per_page], @mongo_bounds[:total]].min
+            else
+              @mongo_bounds.merge!(:pages => 1, :page => 1, :first => 1, :last => @mongo_bounds[:total], :per_page => @mongo_bounds[:total])
+            end            
+          end
+
+          @mongo_bounds
+        end
+
+        def mongo_fetch_data(args = {})
+          @mongo_records = @mongo_query.order_by(@mongo_sort_order)
+          self.mongo_calculate_bounds(args.reverse_merge(:per_page => (args[:per_page] || params[args[:parameter] || :count])))
+          @records = @mongo_records.skip(@mongo_bounds[:first] - 1).limit(@mongo_bounds[:per_page])
+          @mongo_pager = WillPaginate::Collection.new(@mongo_bounds[:page], @mongo_bounds[:per_page], @mongo_bounds[:total])
+        end  
+
+        def mongo_reset_query(args = {})
+          klass = args[:class] || @mongo_class
+          klass ? (args[:also_deleted] ? klass.where : klass.not_deleted) : nil
+        end
+        
+        def mongo_dump_query(args = {})
+          raise Exception.new("QUERY:\n#{@mongo_query.inspect}")
+        end
+
+        def mongo_add_query_conditions(args = {})
+          (args[:conditions] || []).ensure_array.each do |condition|
+            @mongo_query = @mongo_query.where(condition) if condition.is_a?(Hash)
+          end
+
+          @mongo_query = yield(@mongo_query) if block_given?
+          @mongo_query
+        end
+
+        def mongo_parse_search(search)
+          if search.present? then
+            # Operate on parenthesis. If unbalanced, no substitution is done
+            if search.gsub(/[^(]/mi, "").strip.length == search.gsub(/[^)]/mi, "").strip.length then
+              # Split token
+              search = search.split(/(\s(AND|OR)\s)|([\(\)])/).select{|t| !t.empty? && t !~ /^(AND|OR)$/}
+
+              # Replace tokens
+              search = search.collect { |token|
+                  case token
+                  when /[\(\)]/ then # No replace
+                    token
+                  when /\sAND\s/ then
+                    "(.+)"
+                  when /\sOR\s/ then
+                    "|"
+                  when /^\^(.+)/ then
+                    "(^(#{Regexp.escape($1)}))"
+                  when /(.+)\$$/ then
+                    "((#{Regexp.escape($1)})$)"
+                  else
+                    "(" + Regexp.escape(token) + ")"
+                end
+              }.join("")
+            else
+              search = Regexp.quote(search)
+            end
+          end
+
+          search
+        end
+
+        def mongo_handle_search(args = {})
+          parameter = args[:parameter] || :search
+
+          # Get the query
+          search_query = params[parameter]
+          if search_query.present? then
+            expr = self.mongo_parse_search(search_query)
+
+            # Build the query
+            (args[:fields] || []).each do |field|
+              @mongo_query = @mongo_query.any_of(field.to_sym => Regexp.new(expr, Regexp::EXTENDED | Regexp::MULTILINE | Regexp::IGNORECASE))
+            end
+
+            # Now add external fields
+            # TODO: Can we enhance this?
+            (args[:external] || []).each do |external|
+              external_query = external[:class].not_deleted
+              (external[:fields] || []).each do |field|
+                external_query = external_query.any_of(field.to_sym => Regexp.new(expr, Regexp::EXTENDED | Regexp::MULTILINE | Regexp::IGNORECASE))
+              end
+
+              ids = external_query.only(:id).all.collect {|r| r.id }
+              @mongo_query = @mongo_query.any_of(:cliente_id.in => ids) if ids.count > 0
+            end    
+          end
+
+          @mongo_query
+        end
+
+        def mongo_handle_sorting(args = {})
+          order = args[:order] || [:current, [:updated_at, :desc]]
+
+          # Get current request sort order and then replace it into the sort fields
+          current = self.mongo_get_sort_param(:default => args[:default])
+          current_index = order.index(:current)
+          order[current_index] = current if current_index
+
+          # Assign data
+          @mongo_sort_order = order    
+        end
+
+        def mongo_form_header(args = {})
+          args[:record].try(:new_record?) ? "Create" : "Edit"
+        end
+
+        def mongo_form_submit_label(args = {})
+          args[:record].try(:new_record?) ? "Create" : "Edit"
+        end
+
+        def mongo_yesno
+          [OpenStruct.new(:value => true, :label => "Sì"), OpenStruct.new(:value => false, :label => "No")]
+        end
+
+        def mongo_get_page_param(args = {})
+          page = [params[args[:parameter] || :page].to_integer, 1].max
+          page = [page, args[:upperbound]].min if args[:upperbound].to_integer > 0
+          page
+        end
+
+        def mongo_get_sort_param(args = {})
+          if /^(?<what>[a-z0-9_]+)-(?<how>asc|desc)$/i.match(params[args[:param] || :sort_by]) && (args[:valids] || []).include?($~["what"]) then
+            [$~["what"].to_sym, $~["how"].downcase.to_sym]
+          else
+            args[:default] || [:created_at, :desc]
+          end
+        end
+
+        def mongo_delete(args = {})
+          record = (args[:class] || @mongo_class).safe_find(args[:id])
+
+          if record then
+            args[:only_check] ? record.deletable? : record.delete(args[:definitive])
+          else
+            false
+          end
+        end
+  
+        def mongo_exists?(args)
+          args[:class].not_deleted.where(args[:conditions]).count > 0
+        end
+  
+        def mongo_is_available?(args = {})
+          rv = self.setup_json_response(:validator)
+          rv["success"] = true
+          rv["valid"] = (self.mongo_exists?(args) == (args[:must_exists] || false))
+          args[:internal] ? rv : self.custom_respond_with(rv.to_json)
+        end
+  
+        def mongo_update_params_black_list(args = {})
+          ["controller", "action", "id", "subdomain"] + (args[:additional] || [])
+        end
+
+        def mongo_update_params(args = {})
+          blacklist = self.mongo_update_params_black_list(args)
+          session["params-#{self.location_name}"] = (params.delete_if {|k,v| blacklist.include?(k) || params[k].is_a?(Tempfile) || params[k].blank?})
+        end
+
+        def mongo_end_write_action(args = {})
+          redirect_to self.mongo_end_write_action_url(args)
+        end
+
+        def mongo_end_write_action_url(args = {})
+          rp = {}
+
+          if !args[:absolute] then
+            rp = session["params-#{self.location_name(:index)}"] || {}
+            rp[:action] = :index
+          end
+
+          if args[:additional].is_a?(Hash) then
+            args[:additional].each { |k, v| rp[k] = v }
+          end
+
+          url_for(rp)
+        end
+      end
+    end
+  end
+end

data/app/models/cowtech/ruby_on_rails/models/ar/model_base.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+#
+# This file is part of the cowtech-rails gem. Copyright (C) 2011 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Cowtech
+  module RubyOnRails
+    module Models
+      module Ar
+        if defined?(ActiveRecord) then
+          class ModelBase < ::ActiveRecord::Base
+            def self.deleted_column
+              "deleted_at"
+            end
+        
+            def self.status_column
+              "status_id"
+            end
+        
+            def self.deleted_status_id
+              0
+            end
+        
+            def self.[](what, only_id = false)
+              self.__finalize(self.__safe_index_find(what), only_id) 
+            end
+        
+            def safe_id
+              if self.id then self.id else 0 end
+            end
+        
+            def editable?(user = nil)
+              true
+            end
+  
+            def deletable?(user = nil)
+              true
+            end
+        
+            def delete(definitive = false)
+              if !definitive then
+                if self.deletable? then
+                  if self.has_attribute?(self.class.deleted_column) then
+                    self.update_attribute(self.class.deleted_column, DateTime.now)
+                    true
+                  elsif self.has_attribute?(self.class.status_column) then
+                    self.update_attribute(self.class.status_column, self.deleted_status)
+                    true
+                  else
+                    super()
+                  end
+                else
+                  false
+                end
+              else
+                super()
+              end
+            end
+        
+            def is?(other)
+              other ? (self.id == self.class.__safe_index_find(other).id) : false
+            end
+
+            private
+              def self.__index_find(what)
+                self.find(what)
+              end
+          
+              def self.__finalize(record, only_id = false)
+                if record then
+                  only_id ? record.id : record
+                else
+                  nil
+                end
+              end          
+          
+              def self.__safe_index_find(what)
+                record = nil
+            
+                begin
+                  record = self.__index_find(what)
+                rescue ActiveRecord::RecordNotFound
+                  record = nil
+                end
+          
+                record
+              end
+          end
+        else
+          class ModelBase
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/cowtech/ruby_on_rails/models/mongoid/cowtech.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+#
+# This file is part of the Gestione Exodus Comics application. Copyright (C) 2010 and above Paolo Insogna <p.insogna@me.com>.
+# Licensed as stated in the COPYRIGHT file, which can be found in the root of the application.
+#
+
+module Cowtech
+  module RubyOnRails
+    module Models
+      module Mongoid
+        module Cowtech
+          extend ActiveSupport::Concern
+
+          # Uncomment for numeric ID
+          # included do
+          #   include Mongoid::Sequence
+          #   identity :type => Integer 
+          #   sequence :_id      
+          # end
+  
+          module ClassMethods
+            def [](what, only_id = false)
+              self.__finalize(self.__safe_index_find(what), only_id) 
+            end
+    
+            def find_or_create(oid, attributes = nil)
+              self.safe_find(oid) || self.new(attributes)
+            end
+    
+            def safe_find(oid)        
+              rv = oid.blank? ? nil : self.find(BSON::ObjectId(oid))
+            rescue ::Mongoid::Errors::DocumentNotFound, BSON::InvalidObjectId
+              nil
+            end
+
+            def random
+              c = self.count
+              c != 0 ? self.skip(rand(c)).first : nil
+            end
+
+            def per_page
+              25
+            end
+    
+            # Overrides for paranoia module to allow find associations on deleted documents
+            def criteria(*args)
+              rv = super
+              rv.selector = {}
+              rv
+            end
+    
+            def not_deleted
+              where(:deleted_at.exists => false)
+            end
+    
+            def __index_find(oid)
+              oid.blank? ? nil : self.find(BSON::ObjectId(oid))
+            rescue ::Mongoid::Errors::DocumentNotFound, BSON::InvalidObjectId
+              nil
+            end
+    
+            def __finalize(record, only_id = false)
+              record ? (only_id ? record.id : record) : nil
+            end          
+    
+            def __safe_index_find(what)
+              self.__index_find(what)
+            rescue ::Mongoid::Errors::DocumentNotFound, BSON::InvalidObjectId
+              nil
+            end
+          end
+  
+          module InstanceMethods
+            # Decommentare per ID di tipo numerico
+            # def safe_id
+            #   self.id ? self.id : 0
+            # end
+    
+            def editable?(user = nil)
+              true
+            end
+
+            def deletable?(user = nil)
+              true
+            end
+    
+            def delete(definitive = false)
+              if definitive != true then
+                if self.deletable? then
+                  super()
+                  true
+                else
+                  false
+                end
+              else
+                self.delete!
+              end
+            end
+    
+            def is?(other)
+              other ? (self.id == self.class.__safe_index_find(other).id) : false
+            end
+          end 
+        end
+      end
+    end
+  end
+end

data/app/models/cowtech/ruby_on_rails/models/mongoid/logging.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+# This file is part of the Gestione Exodus Comics application. Copyright (C) 2010 and above Paolo Insogna <p.insogna@me.com>.
+# Licensed as stated in the COPYRIGHT file, which can be found in the root of the application.
+#
+
+module Cowtech
+  module RubyOnRails
+    module Models
+      module Mongoid
+        module Logging
+          extend ActiveSupport::Concern
+    
+          included do
+            set_callback(:create, :after) { |d| d.log_activity(:create) }
+            set_callback(:update, :after) { |d| d.log_activity(:update) }    
+          end
+        
+          module InstanceMethods
+            def delete(options = {})
+              log_activity(:delete)
+              super(options)
+            end
+
+            def restore
+              log_activity(:restore)
+              super
+            end
+          end    
+        end
+      end
+    end
+  end
+end

data/app/models/cowtech/ruby_on_rails/models/mongoid/sequence.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+#
+# This file is part of the Gestione Exodus Comics application. Copyright (C) 2010 and above Paolo Insogna <p.insogna@me.com>.
+# Licensed as stated in the COPYRIGHT file, which can be found in the root of the application.
+#
+
+module Cowtech
+  module RubyOnRails
+    module Models
+      module Mongoid
+        # Include this module to add automatic sequence feature (also works for _id field, so SQL-Like autoincrement primary key can easily be simulated)
+        # usage:
+        # class KlassName
+        #   include Mongoid::Document
+        #   include Mongoid::Sequence
+        # ...
+        #   field :number, :type=>Integer
+        #   sequence :number
+        # ...
+        module Sequence
+          extend ActiveSupport::Concern
+        
+          module ClassMethods
+            def sequence(_field)
+              # REPLACE FIELD DEFAULT VALUE
+              _field = _field.to_s
+              field(_field, fields[_field].options.merge(:default => lambda{ set_from_sequence(_field)}))
+            end
+      
+            def set_from_sequence(_field)
+              sequences = self.db.collection("__sequences")
+              counter_id = "#{self.class.name.underscore}_#{_field}"
+
+              # Increase the sequence value and also avoids conflicts
+              catch(:value) do
+                value = nil
+                begin
+                  value = sequences.find_and_modify(
+                    :query => {"_id" => counter_id},
+                    :update=> {"$inc" => {"value" => 1}},
+                    :new => true,
+                    :upsert => true
+                  ).send("[]", "value")
+                end while self.first({:conditions => {_field => value}})
+                throw :value, value
+              end
+            end    
+      
+            def reset_sequence(_field)  
+              sequences = self.db.collection("__sequences")
+              counter_id = "#{self.class.name.underscore}_#{_field.to_s}"
+              sequences.find_and_modify(:query => {"_id" => counter_id}, :update=> {"$set" => {"value" => 0}}, :new => true, :upsert => true)
+            end
+          end    
+        end
+      end
+    end
+  end
+end

data/lib/cowtech/version.rb

@@ -7,10 +7,10 @@
 module Cowtech
   module Rails
     module Version
-      MAJOR = 1
-      MINOR = 9
-      PATCH = 7
-      BUILD = 6
+      MAJOR = 2
+      MINOR = 0
+      PATCH = 0
+      BUILD = 0
 
       STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cowtech-rails
 version: !ruby/object:Gem::Version
-  version: 1.9.7.6
+  version: 2.0.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-23 00:00:00.000000000Z
+date: 2011-08-31 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cowtech-extensions
-  requirement: &70126381000440 !ruby/object:Gem::Requirement
+  requirement: &70163803747200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70126381000440
+  version_requirements: *70163803747200
 description: A general purpose Rails utility plugin.
 email: shogun_panda@me.com
 executables: []
@@ -30,12 +30,16 @@ extra_rdoc_files:
 - README
 files:
 - app/helpers/cowtech/ruby_on_rails/helpers/application_helper.rb
+- app/helpers/cowtech/ruby_on_rails/helpers/ar_crud_helper.rb
 - app/helpers/cowtech/ruby_on_rails/helpers/browser_helper.rb
-- app/helpers/cowtech/ruby_on_rails/helpers/crud_helper.rb
 - app/helpers/cowtech/ruby_on_rails/helpers/format_helper.rb
+- app/helpers/cowtech/ruby_on_rails/helpers/mongoid_crud_helper.rb
 - app/helpers/cowtech/ruby_on_rails/helpers/validation_helper.rb
+- app/models/cowtech/ruby_on_rails/models/ar/model_base.rb
 - app/models/cowtech/ruby_on_rails/models/e_mail.rb
-- app/models/cowtech/ruby_on_rails/models/model_base.rb
+- app/models/cowtech/ruby_on_rails/models/mongoid/cowtech.rb
+- app/models/cowtech/ruby_on_rails/models/mongoid/logging.rb
+- app/models/cowtech/ruby_on_rails/models/mongoid/sequence.rb
 - lib/cowtech.rb
 - lib/cowtech/extensions.rb
 - lib/cowtech/monkey_patches.rb

data/app/models/cowtech/ruby_on_rails/models/model_base.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the cowtech-rails gem. Copyright (C) 2011 and above Shogun <shogun_panda@me.com>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Cowtech
-  module RubyOnRails
-    module Models
-      if defined?(ActiveRecord) then
-        class ModelBase < ::ActiveRecord::Base
-          def self.deleted_column
-            "deleted_at"
-          end
-        
-          def self.status_column
-            "status_id"
-          end
-        
-          def self.deleted_status_id
-            0
-          end
-        
-          def self.[](what, only_id = false)
-            self.__finalize(self.__safe_index_find(what), only_id) 
-          end
-        
-          def safe_id
-            if self.id then self.id else 0 end
-          end
-        
-          def editable?(user = nil)
-            true
-          end
-  
-          def deletable?(user = nil)
-            true
-          end
-        
-          def delete(definitive = false)
-            if !definitive then
-              if self.deletable? then
-                if self.has_attribute?(self.class.deleted_column) then
-                  self.update_attribute(self.class.deleted_column, DateTime.now)
-                  true
-                elsif self.has_attribute?(self.class.status_column) then
-                  self.update_attribute(self.class.status_column, self.deleted_status)
-                  true
-                else
-                  super()
-                end
-              else
-                false
-              end
-            else
-              super()
-            end
-          end
-        
-          def is?(other)
-            other ? (self.id == self.class.__safe_index_find(other).id) : false
-          end
-
-          private
-            def self.__index_find(what)
-              self.find(what)
-            end
-          
-            def self.__finalize(record, only_id = false)
-              if record then
-                only_id ? record.id : record
-              else
-                nil
-              end
-            end          
-          
-            def self.__safe_index_find(what)
-              record = nil
-            
-              begin
-                record = self.__index_find(what)
-              rescue ActiveRecord::RecordNotFound
-                record = nil
-              end
-          
-              record
-            end
-        end
-      else
-        class ModelBase
-        end
-      end
-    end
-  end
-end