harukizaemon-drupal_fu 1.0.0

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+== 1.0.0 released 2009-01-12
+
+* Add some very basic RDOC and packaged up as a gem.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Cogent Consulting, Pty. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= Drupal Fu
+
+Drupal Fu is a Ruby on Rails plugin that helps with integrating Rails applications with Drupal.
+
+== Installation
+
+You have two choices for installation. The first uses a gem (recommended):
+
+  config.gem "harukizaemon-drupal_fu", :lib => "drupal_fu", :source => "http://gems.github.com"
+
+Or you can use the Rails plugin
+
+  $ ruby script/plugin install git://github.com/harukizaemon/drupal_fu.git
+
+=== License
+
+This plugin is copyright 2009 by 2009 Cogent Consulting, Pty. Ltd. and is released under the MIT license.

data/drupal_fu.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name     = "drupal_fu"
+  s.version  = "1.0.0"
+  s.date     = "2009-01-12"
+  s.summary  = "Ruby on Rails Models and Helpers for integrating with Drupal."
+  s.email    = "simon.harris@cogentconsulting.com.au"
+  s.homepage = "http://github.com/harukizaemon/drupal_fu"
+  s.description = "Ruby on Rails Models and Helpers for integrating with Drupal."
+  s.has_rdoc = true
+  s.authors  = ["Simon Harris"]
+  s.files    = ["CHANGELOG.rdoc",
+                "MIT-LICENSE",
+                "README.rdoc",
+                "drupal_fu.gemspec",
+                "lib/drupal/authmap.rb",
+                "lib/drupal/base.rb",
+                "lib/drupal/helper.rb",
+                "lib/drupal/menu_link.rb",
+                "lib/drupal/menu_router.rb",
+                "lib/drupal/profile_field.rb",
+                "lib/drupal/serialize.rb",
+                "lib/drupal/session.rb",
+                "lib/drupal/session_store.rb",
+                "lib/drupal/url_alias.rb",
+                "lib/drupal/user.rb",
+                "lib/drupal/variable.rb",
+                "lib/drupal_fu.rb",
+                "lib/tasks",
+                "lib/tasks/drupal.rake"]
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = ["CHANGELOG.rdoc", "README.rdoc"]
+end

data/lib/drupal/authmap.rb

@@ -0,0 +1,6 @@
+module Drupal
+  class Authmap < Base
+    set_table_name "authmap"
+    set_primary_key "aid"
+  end
+end

data/lib/drupal/base.rb

@@ -0,0 +1,31 @@
+module Drupal
+  # Base class for all Drupal-specific model classes. If your Rails and Drupal applications share a common database then
+  # you can use this class as is. If your Drupal database is seperate, you can do something along the lines of the
+  # following in environment.rb:
+  #
+  #   Drupal::Base.establish_connection "drupal_#{RAILS_ENV}"
+  #
+  # And add the corresponding entries in database.yml; one for each environment.
+  class Base < ActiveRecord::Base
+    self.abstract_class = true
+    
+    protected
+
+      # Convenience method for marking model attributes as serialized. Supports a Ruby-compatible subset of the PHP
+      # serialisation mechanism.
+      def self.serializes(*attr_names)
+        attr_names.each do |attr_name|
+          class_eval <<-EOS
+            def #{attr_name}
+              @unserialized_#{attr_name} ||= Drupal::Serialize.unserialize(super)
+            end
+  
+            def #{attr_name}=(new_value)
+              @unserialized_#{attr_name} = new_value
+              super Drupal::Serialize.serialize(new_value)
+            end
+          EOS
+        end
+      end
+  end
+end

data/lib/drupal/helper.rb

@@ -0,0 +1,46 @@
+module Drupal
+  # Some useful helper methods for accessing various configuration items. Simply include this module in whichever
+  # controller(s) need the behaviour. For example:
+  #
+  #   class ApplicationController < ActionController::Base
+  #     include Drupal::Helper
+  #     ...
+  #   end
+  module Helper
+    def self.included(base)
+      base.send(:helper_method, :primary_links, :root_path, :login_path, :site_name, :site_slogan)
+    end
+
+    protected
+
+      def primary_links
+        @primary_links ||= menu_links('primary-links')
+      end
+      
+      def root_path
+        "/"
+      end
+
+      def login_path
+        @login_path ||= Drupal::UrlAlias.url_for("/user/login")
+      end
+
+      def site_name
+        @site_name ||= Drupal::Variable.value_of("site_name")
+      end
+
+      def site_slogan
+        @site_slogan ||= Drupal::Variable.value_of("site_slogan")
+      end
+
+    private
+
+      def menu_links(name)
+        Drupal::MenuLink.find(:all,
+          :joins => :menu_router,
+          :conditions => ["menu_name = ? AND hidden = 0 AND #{Drupal::MenuRouter.table_name}.access_callback <> 'user_is_anonymous'", name],
+          :order => "weight",
+          :readonly => true)
+      end
+  end
+end

data/lib/drupal/menu_link.rb

@@ -0,0 +1,15 @@
+module Drupal
+  class MenuLink < Base
+    set_primary_key "mlid"
+    serializes "options"
+    belongs_to :menu_router, :foreign_key => "router_path", :class_name => "Drupal::MenuRouter"
+
+    def title
+      link_title
+    end
+    
+    def path
+      @path ||= Drupal::UrlAlias.url_for(link_path)
+    end
+  end
+end

data/lib/drupal/menu_router.rb

@@ -0,0 +1,9 @@
+module Drupal
+  class MenuRouter < Base
+    set_table_name "menu_router"
+    set_primary_key "path"
+    self.inheritance_column = nil
+    serializes "access_arguments", "page_arguments", "title_arguments", "load_functions", "to_arg_functions"
+    has_many :menu_links, :foreign_key => "router_path", :class_name => "Drupal::MenuLink"
+  end
+end

data/lib/drupal/profile_field.rb

@@ -0,0 +1,19 @@
+module Drupal
+  class ProfileField < Base
+    set_primary_key "fid"
+    self.inheritance_column = nil
+    has_and_belongs_to_many :users, :class_name => "Drupal::User", :join_table => "profile_values", :foreign_key => "fid", :association_foreign_key => "uid"
+
+    def value
+      @unserialized_value ||= case self[:type]
+        when "checkbox" then super != "0"
+        when "url" then URI.parse(super)
+        when "date"
+          hash = Serialize.unserialize(super)
+          Date.new(hash["year"].to_i, hash["month"].to_i, hash["day"].to_i)
+        when "list" then super.split(/[,\n\r]/).map(&:strip)
+        else super
+      end
+    end
+  end
+end

data/lib/drupal/serialize.rb

@@ -0,0 +1,189 @@
+module Drupal
+  # Implements a Ruby-compatible subset of the PHP serialisation mechanism. This is often used for storing structured
+  # data in text database columns.
+  module Serialize
+    # Serialises a value. For example:
+    #
+    #   Drupal::Serialize.serialize("Hello, World!")  # => "s:13:\"Hello, World!\";"
+  	def self.serialize(var, assoc = false)
+  		s = ''
+  		case var
+  			when Array
+  				s << "a:#{var.size}:{"
+  				if assoc and var.first.is_a?(Array) and var.first.size == 2
+  					var.each { |k,v|
+  						s << self.serialize(k) << self.serialize(v)
+  					}
+  				else
+  					var.each_with_index { |v,i|
+  						s << "i:#{i};#{self.serialize(v)}"
+  					}
+  				end
+
+  				s << '}'
+
+  			when Hash
+  				s << "a:#{var.size}:{"
+  				var.each do |k,v|
+  					s << "#{self.serialize(k)}#{self.serialize(v)}"
+  				end
+  				s << '}'
+
+  			when Struct
+  				# encode as Object with same name
+  				s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+  				var.members.each do |member|
+  					s << "#{self.serialize(member)}#{self.serialize(var[member])}"
+  				end
+  				s << '}'
+
+  			when String
+  				s << "s:#{var.length}:\"#{var}\";"
+
+  			when Fixnum # PHP doesn't have bignums
+  				s << "i:#{var};"
+
+  			when Float
+  				s << "d:#{var};"
+
+  			when NilClass
+  				s << 'N;'
+
+  			when FalseClass, TrueClass
+  				s << "b:#{var ? 1 :0};"
+
+  			else
+  				if var.respond_to?(:to_assoc)
+  					v = var.to_assoc
+  					# encode as Object with same name
+  					s << "O:#{var.class.to_s.length}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+  					v.each do |k,v|
+  						s << "#{self.serialize(k.to_s)}#{self.serialize(v)}"
+  					end
+  					s << '}'
+  				else
+  					raise TypeError, "Unable to serialize type #{var.class}"
+  				end
+  		end
+
+  		s
+  	end
+
+    # Unserialises a value. For example:
+    #
+    #   Drupal::Serialize.unserialize("s:13:\"Hello, World!\";")  # "Hello, World!"
+  	def self.unserialize(string, classmap = nil, assoc = false)
+  		string = StringIO.new(string)
+  		def string.read_until(char)
+  			val = ''
+  			while (c = self.read(1)) != char
+  				val << c
+  			end
+  			val
+  		end
+
+  		classmap ||= Hash.new
+
+  		_unserialize(string, classmap, assoc)
+  	end
+
+    private
+
+    	def self._unserialize(string, classmap, assoc)
+    		val = nil
+    		# determine a type
+    		type = string.read(2)[0,1]
+    		case type
+    			when 'a' # associative array, a:length:{[index][value]...}
+    				count = string.read_until('{').to_i
+    				val = vals = Array.new
+    				count.times do |i|
+    					vals << [_unserialize(string, classmap, assoc), _unserialize(string, classmap, assoc)]
+    				end
+    				string.read(1) # skip the ending }
+
+    				unless assoc
+    					# now, we have an associative array, let's clean it up a bit...
+    					# arrays have all numeric indexes, in order; otherwise we assume a hash
+    					array = true
+    					i = 0
+    					vals.each do |key,value|
+    						if key != i # wrong index -> assume hash
+    							array = false
+    							break
+    						end
+    						i += 1
+    					end
+
+    					if array
+    						vals.collect! do |key,value|
+    							value
+    						end
+    					else
+    						val = Hash.new
+    						vals.each do |key,value|
+    							val[key] = value
+    						end
+    					end
+    				end
+
+    			when 'O' # object, O:length:"class":length:{[attribute][value]...}
+    				# class name (lowercase in PHP, grr)
+    				len = string.read_until(':').to_i + 3 # quotes, seperator
+    				klass = string.read(len)[1...-2].capitalize.intern # read it, kill useless quotes
+
+    				# read the attributes
+    				attrs = []
+    				len = string.read_until('{').to_i
+
+    				len.times do
+    					attr = (_unserialize(string, classmap, assoc))
+    					attrs << [attr.intern, (attr << '=').intern, _unserialize(string, classmap, assoc)]
+    				end
+    				string.read(1)
+
+    				val = nil
+    				# See if we need to map to a particular object
+    				if classmap.has_key?(klass)
+    					val = classmap[klass].new
+    				elsif Struct.const_defined?(klass) # Nope; see if there's a Struct
+    					classmap[klass] = val = Struct.const_get(klass)
+    					val = val.new
+    				else # Nope; see if there's a Constant
+    					begin
+    						classmap[klass] = val = Module.const_get(klass)
+
+    						val = val.new
+    					rescue NameError # Nope; make a new Struct
+    						classmap[klass] = val = Struct.new(klass.to_s, *attrs.collect { |v| v[0].to_s })
+    					end
+    				end
+
+    				attrs.each do |attr,attrassign,v|
+    					val.__send__(attrassign, v)
+    				end
+
+    			when 's' # string, s:length:"data";
+    				len = string.read_until(':').to_i + 3 # quotes, separator
+    				val = string.read(len)[1...-2] # read it, kill useless quotes
+
+    			when 'i' # integer, i:123
+    				val = string.read_until(';').to_i
+
+    			when 'd' # double (float), d:1.23
+    				val = string.read_until(';').to_f
+
+    			when 'N' # NULL, N;
+    				val = nil
+
+    			when 'b' # bool, b:0 or 1
+    				val = (string.read(2)[0] == ?1 ? true : false)
+
+    			else
+    				raise TypeError, "Unable to unserialize type '#{type}'"
+    		end
+
+    		val
+    	end
+  end
+end

data/lib/drupal/session.rb

@@ -0,0 +1,35 @@
+module Drupal
+  class Session < Base
+    set_primary_key "sid"
+    belongs_to :user, :foreign_key => "uid", :class_name => "Drupal::User"
+
+    def self.authenticate(sid)
+      find(:first, :conditions => ["#{table_name}.sid = ? AND #{User.table_name}.status = 1", sid], :include => :user)
+    end
+
+    def session
+      @unserialized_session ||= decode(super || "")
+    end
+    
+    def session=(new_value)
+      @unserialized_data = new_value
+      super encode(new_value)
+    end
+
+    private
+    
+      def encode(data)
+        result = ""
+        data.each { |key, value| result << key << "|" << Drupal::Serialize.serialize(value) }
+        result
+      end
+    
+      def decode(data)
+        result = {}
+        vars = data.split(/([a-zA-Z0-9]+)\|/)
+        vars.shift
+        vars.each_slice(2) { |pair| result[pair.first] = Drupal::Serialize.unserialize(pair.last) }
+        result
+      end
+  end
+end

data/lib/drupal/session_store.rb

@@ -0,0 +1,65 @@
+module Drupal
+  class SessionStore
+    def self.stub(login)    
+      self.class_eval <<-EOS
+        def initialize_with_stubbing(session, options = {})
+          user = Drupal::User.find_or_create_by_name("#{login}")
+          user.update_attributes!(:status => 1)
+          Drupal::Session.find_or_create_by_sid_and_uid(session.session_id, user.uid)
+          initialize_without_stubbing(session, options)
+        end
+        alias_method_chain :initialize, :stubbing
+EOS
+
+      Digest::MD5.hexdigest(login)
+    end
+
+    def initialize(session, options = {})
+      @session = Drupal::Session.authenticate(session.session_id)
+      raise CGI::Session::NoSession, "uninitialized session" if @session.nil?
+    end
+
+    # Restore session data from the record.
+    def restore
+      @data = decode(@session.session)
+    end
+
+    # Wait until close to write the session data.
+    def update; end
+
+    # Update the database.
+    def close
+      now = Time.now.to_i
+      @session.timestamp = now
+      @session.session = encode(@data) if defined?(@data)
+      @session.save!
+      @session.user.access = now
+      @session.user.save!
+      @session = nil
+      @data = nil
+    end
+
+    # This is handled by Drupal.
+    def delete
+      @session = nil
+      @data = nil
+    end
+
+    private
+
+      def encode(data)
+        data = data.dup
+        data.delete(:user)
+        data.delete("flash") if data["flash"].blank?
+        data
+      end
+
+      def decode(data)
+        data = data.dup
+        flash = data["flash"]
+        data["flash"] = ActionController::Flash::FlashHash.new.replace(flash) if flash
+        data[:user] = @session.user
+        data
+      end
+  end
+end

data/lib/drupal/url_alias.rb

@@ -0,0 +1,14 @@
+module Drupal
+  class UrlAlias < Base
+    set_table_name "url_alias"
+    set_primary_key "pid"
+
+    def self.url_for(path, language = "")
+      if url_alias = self.find_by_src_and_language(path, language)
+        url_alias.dst
+      else
+        path
+      end
+    end
+  end
+end

data/lib/drupal/user.rb

@@ -0,0 +1,36 @@
+module Drupal
+  class User < Base
+    set_primary_key "uid"
+
+    has_many :sessions, :foreign_key => "sid", :class_name => "Drupal::Session"
+    has_and_belongs_to_many :profile_fields, :class_name => "Drupal::ProfileField", :join_table => "profile_values", :foreign_key => "uid", :association_foreign_key => "fid"
+    has_many :openids, :foreign_key => "uid", :class_name => "Drupal::Authmap", :conditions => { :module => "openid" }
+    serializes "data"
+
+    # Authenticate a user given a name and password. For example:
+    #
+    #   if user = Drupal::User.authenticate("bob", "flibble")
+    #     # At this point, we have a valid user record
+    #   else
+    #     # Could be an invalid user/password combo or the user might be blocked
+    #   end
+    def self.authenticate(name, password)
+      find_by_name_and_pass_and_status(name, Digest::MD5.hexdigest(password), 1)
+    end
+
+    # Returns true if the user is allowed to login.
+    def active?
+      status == 1
+    end
+
+    # Returns true if the user has been barred from logging in.
+    def blocked?
+      !active?
+    end
+
+    # Returns true if the user is the system administrator account.
+    def administrator?
+      uid == 1
+    end
+  end
+end

data/lib/drupal/variable.rb

@@ -0,0 +1,13 @@
+module Drupal
+  class Variable < Base
+    set_table_name "variable"
+    set_primary_key "name"
+    serializes "value"
+
+    def self.value_of(name)
+      if variable = self.find_by_name(name)
+        variable.value
+      end
+    end
+  end
+end

data/lib/drupal_fu.rb

@@ -0,0 +1 @@
+# Do stuff

data/lib/tasks/drupal.rake

@@ -0,0 +1,37 @@
+namespace :drupal do
+  namespace :db do
+    namespace :test do
+      desc "Empty the drupal test database"
+      task :purge => :environment do
+        abcs = ActiveRecord::Base.configurations
+        ActiveRecord::Base.clear_active_connections!
+        drop_database(abcs['drupal_test'])
+        create_database(abcs['drupal_test'])
+      end
+
+      desc "Prepare the drupal test database"
+      task :prepare => "drupal:db:test:purge" do
+        Drupal::Base.establish_connection(ActiveRecord::Base.configurations['drupal_test'])
+        ActiveRecord::Schema.verbose = false
+        Rake::Task["drupal:db:schema:load"].invoke
+      end
+    end
+
+    namespace :schema do
+      desc "Create a db/drupal_schema.rb file that can be portably used against any DB supported by AR"
+      task :dump => :environment do
+        require 'active_record/schema_dumper'
+        File.open(ENV['DRUPAL_SCHEMA'] || "db/drupal_schema.rb", "w") do |file|
+          ActiveRecord::SchemaDumper.dump(Drupal::Base.connection, file)
+        end
+      end
+    
+      desc "Load a drupal_schema.rb file into the database"
+      task :load => :environment do
+        ActiveRecord::Base.connection = Drupal::Base.connection
+        load(ENV['DRUPAL_SCHEMA'] || "db/drupal_schema.rb")
+        ActiveRecord::Base.clear_active_connections!
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: harukizaemon-drupal_fu
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Simon Harris
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Ruby on Rails Models and Helpers for integrating with Drupal.
+email: simon.harris@cogentconsulting.com.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG.rdoc
+- README.rdoc
+files: 
+- CHANGELOG.rdoc
+- MIT-LICENSE
+- README.rdoc
+- drupal_fu.gemspec
+- lib/drupal/authmap.rb
+- lib/drupal/base.rb
+- lib/drupal/helper.rb
+- lib/drupal/menu_link.rb
+- lib/drupal/menu_router.rb
+- lib/drupal/profile_field.rb
+- lib/drupal/serialize.rb
+- lib/drupal/session.rb
+- lib/drupal/session_store.rb
+- lib/drupal/url_alias.rb
+- lib/drupal/user.rb
+- lib/drupal/variable.rb
+- lib/drupal_fu.rb
+- lib/tasks
+- lib/tasks/drupal.rake
+has_rdoc: true
+homepage: http://github.com/harukizaemon/drupal_fu
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby on Rails Models and Helpers for integrating with Drupal.
+test_files: []
+