rhodes 0.1.0

data/lib/rho/rhosupport.rb

@@ -0,0 +1,139 @@
+module Rho
+  module RhoSupport
+
+    class << self
+      def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end
+	
+      ESCAPED = /%([0-9a-fA-F]{2})/
+	
+      def unescape_form(str)
+        _unescape(str.gsub(/\+/, " "), ESCAPED)
+      end
+
+      def parse_query_parameters(query_string)
+        return {} if query_string.nil?
+
+        pairs = query_string.split('&').collect do |chunk|
+          next if chunk.empty?
+          key, value = chunk.split('=', 2)
+          next if key.empty?
+          value = value.nil? ? nil : unescape_form(value)
+          [ unescape_form(key), value ]
+        end.compact
+
+        UrlEncodedPairParser.new(pairs).result
+      end
+		
+      def query_params(req)
+        params = {}
+        unless req['id'].nil?
+          params['id'] = req['id']
+        end
+        unless req['request-query'].nil? or req['request-query'].length == 0
+          params.merge!(parse_query_parameters(req['request-query']))				
+        end
+        unless req['headers'].nil? or req['headers']['Content-Type'].nil?
+          if 'application/x-www-form-urlencoded'.eql? req['headers']['Content-Type']
+            params.merge!(parse_query_parameters(req['request-body']))
+          end	
+        end
+        puts "Params: " + params.to_s unless params.empty?
+        params
+      end
+    end
+	
+    class UrlEncodedPairParser < StringScanner #:nodoc:
+      attr_reader :top, :parent, :result
+
+      def initialize(pairs = [])
+        super('')
+        @result = {}
+        pairs.each { |key, value| parse(key, value) }
+      end
+
+      KEY_REGEXP = %r{([^\[\]=&]+)}
+      BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
+
+      # Parse the query string
+      def parse(key, value)
+        self.string = key
+        @top, @parent = result, nil
+
+        # First scan the bare key
+        key = scan(KEY_REGEXP) or return
+        key = post_key_check(key)
+
+        # Then scan as many nestings as present
+        until eos?
+          r = scan(BRACKETED_KEY_REGEXP) or return
+          key = self[1]
+          key = post_key_check(key)
+        end
+
+        bind(key, value)
+      end
+
+      private
+      # After we see a key, we must look ahead to determine our next action. Cases:
+      #
+      #   [] follows the key. Then the value must be an array.
+      #   = follows the key. (A value comes next)
+      #   & or the end of string follows the key. Then the key is a flag.
+      #   otherwise, a hash follows the key.
+      def post_key_check(key)
+        if scan(/\[\]/) # a[b][] indicates that b is an array
+          container(key, Array)
+          nil
+        elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
+          container(key, Hash)
+          nil
+        else # End of key? We do nothing.
+          key
+        end
+      end
+
+      # Add a container to the stack.
+      def container(key, klass)
+        type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
+        value = bind(key, klass.new)
+        type_conflict! klass, value unless value.is_a?(klass)
+        push(value)
+      end
+
+      # Push a value onto the 'stack', which is actually only the top 2 items.
+      def push(value)
+        @parent, @top = @top, value
+      end
+
+      # Bind a key (which may be nil for items in an array) to the provided value.
+      def bind(key, value)
+        if top.is_a? Array
+          if key
+            if top[-1].is_a?(Hash) && ! top[-1].key?(key)
+              top[-1][key] = value
+            else
+              top << {key => value}.with_indifferent_access
+              push top.last
+              value = top[key]
+            end
+          else
+            top << value
+          end
+        elsif top.is_a? Hash
+          #key = CGI.unescape(key)
+          parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
+          top[key] ||= value
+          return top[key]
+        else
+          raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
+        end
+
+        return value
+      end
+
+      def type_conflict!(klass, value)
+        raise TypeError, "Conflicting types for parameter containers. Expected an instance of #{klass} but found an instance of #{value.class}. This can be caused by colliding Array and Hash parameters like qs[]=value&qs[key]=value. (The parameters received were #{value.inspect}.)"
+      end
+    end
+  end # RhoSupport
+end # Rho

data/lib/rhodes.rb

@@ -0,0 +1,5 @@
+module Rhodes
+  unless defined? Rhodes::VERSION
+    VERSION = '0.1.0'
+  end
+end

data/lib/rhofsconnector.rb

@@ -0,0 +1,5 @@
+if defined? RHO_ME
+	require 'rho/rhofsconnectorME.rb'
+else
+	require 'rho/rhofsconnector.rb'
+end

data/lib/rhom.rb

@@ -0,0 +1 @@
+require 'rhom/rhom'

data/lib/rhom/rhom.rb

@@ -0,0 +1,41 @@
+#
+#  rhom.rb
+#  rhodes
+#  This module represents the rhodes mini OM
+#
+#  Copyright (C) 2008 Lars Burgess. All rights reserved.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'rhom/rhom_object_factory'
+require 'rhom/rhom_object'
+if defined? RHO_ME
+	require 'rhom/rhom_db_adapterME'
+else
+	require 'rhom/rhom_db_adapter'
+end
+
+module Rhom
+  TABLE_NAME = 'object_values'
+  
+  class Rhom
+    include RhomObject
+    attr_accessor :factory
+  
+    def initialize
+      @factory = RhomObjectFactory.new
+    end
+  end # Rhom
+end # Rhom

data/lib/rhom/rhom_db_adapter.rb

@@ -0,0 +1,183 @@
+#
+#  rhom_db_adapter.rb
+#  rhodes
+#
+#  Copyright (C) 2008 Lars Burgess. All rights reserved.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+$:.unshift(File.join(File.dirname(__FILE__), '../../'))
+require 'sqlite3/database'
+
+module Rhom
+  class RhomDbAdapter
+    
+    @@database = nil
+    
+    class << self
+      
+      # maintains a single database connection
+      def open(dbfile=nil)
+        puts "DB name = " + dbfile.inspect
+        unless @@database or dbfile.nil?
+          @@database = SQLite3::Database.new(dbfile)
+        end
+      end
+    
+      # closes the database if and only if it is open
+      def close
+        if @@database and not @@database.closed?
+          @@database.close
+          @@database = nil
+        else
+          return false
+        end
+        return true
+      end   
+    
+      # execute a sql statement
+      # optionally, disable the factory processing 
+      # which returns the result array directly
+      def execute_sql(sql=nil)
+        result = []
+        if sql
+          puts 'query is ' + sql
+          # Make sure we lock the sync engine's mutex
+          # before we perform a database transaction.
+          # This prevents concurrency issues.
+          begin
+            SyncEngine::lock_sync_mutex
+            # execute sql statement inside of transaction
+            # result is returned as an array of hashes
+            @@database.transaction unless @@database.transaction_active?
+            @@database.results_as_hash = true
+            result = @@database.execute sql
+            @@database.commit
+            SyncEngine::unlock_sync_mutex
+          rescue Exception => e
+            puts "exception when running query: #{e}"
+            # make sure we unlock even if there's an error!
+            SyncEngine::unlock_sync_mutex
+          end
+        end
+        puts "returned #{result.length.to_s} records..."
+        result
+      end
+    
+      # generates where clause based on hash
+      def where_str(condition)
+        cond = ""
+        condition.each do |key,value|
+          val = value.is_a?(String) ? "'#{value}'" : "#{value}"
+          cond << " #{key} = #{val} and"
+        end
+        cond[0..cond.length - 5]
+      end
+    
+      # generates value clause based on hash
+      def vals_str(values)
+        vals = ""
+        values.each do |key,value|
+          val = value.is_a?(String) ? "'#{value}'" : "#{value}"
+          vals << "#{key} = #{val},"
+        end
+        vals[0..vals.length - 2]
+      end
+    
+      # support for select statements
+      # this function takes table name, columns (as a comma-separated list),
+      # condition (as a hash), and params (as a hash)
+      # example usage is the following:
+      # select_from_table('object_values', '*', {"source_id"=>2,"update_type"=>'query'},
+      #                   {"order by"=>'object'})
+      # this would return all columns where source_id = 2 and update_type = 'query' ordered
+      # by the "object" column
+      def select_from_table(table=nil,columns=nil,condition=nil,params=nil)
+        query = nil
+        if table and columns and condition
+          if params and params['distinct']
+            query = "select distinct #{columns} from #{table} where #{where_str(condition)}"
+          elsif params and params['order by']
+            query = "select #{columns} from #{table} where #{where_str(condition)} \
+                     order by #{params['order by']}"
+          else
+            query = "select #{columns} from #{table} where #{where_str(condition)}"
+          end
+        elsif table and columns
+          query = "select #{columns} from #{table}"                     
+        end
+        execute_sql query
+      end
+    
+      # inserts a single row into the database
+      # takes the table name and values (hash) as arguments
+      # exmaple usage is the following:
+      # insert_into_table('object_values, {"source_id"=>1,"object"=>"some-object","update_type"=>'delete'})
+      # this would execute the following sql:
+      # insert into object_values (source_id,object,update_type) values (1,'some-object','delete');
+      def insert_into_table(table=nil,values=nil)
+        query = nil
+        cols = ""
+        vals = ""
+        if table and values
+          values.each do |key,val|
+            value = val.is_a?(Fixnum) ? "#{val}," : "'#{val}',"
+            cols << "#{key},"
+            vals << value
+          end
+          cols = cols[0..cols.length - 2]
+          vals = vals[0..vals.length - 2]
+          query = "insert into #{table} (#{cols}) values (#{vals})"
+        end
+        execute_sql query
+      end
+    
+      # deletes rows from a table which satisfy condition (hash)
+      # example usage is the following:
+      # delete_from_table('object_values',{"object"=>"some-object"})
+      # this would execute the following sql:
+      # delete from object_values where object="some-object"
+      def delete_from_table(table=nil,condition=nil)
+        query = nil
+        if table and condition
+          query = "delete from #{table} where #{where_str(condition)}"
+        end
+        execute_sql query
+      end
+    
+      # deletes all rows from a given table
+      def delete_all_from_table(table=nil)
+        query = nil
+        if table
+          query = "delete from #{table}"
+        end
+        execute_sql query
+      end
+    
+      # updates values (hash) in a given table which satisfy condition (hash)
+      # example usage is the following:
+      # update_into_table('object_values',{"value"=>"Electronics"},{"object"=>"some-object", "attrib"=>"industry"})
+      # this executes the following sql:
+      # update table object_values set value='Electronics' where object='some-object' and attrib='industry';
+      def update_into_table(table=nil,values=nil,condition=nil)
+        query = nil
+        vals = values.nil? ? nil : vals_str(values)
+        if table and condition and vals
+          query = "update #{table} set #{vals} where #{where_str(condition)}"
+        end
+        execute_sql query
+      end
+    end # class methods
+  end # RhomDbAdapter
+end # Rhom

data/lib/rhom/rhom_db_adapterME.rb

@@ -0,0 +1,91 @@
+#
+#  rhom_db_adapter.rb
+#  rhodes
+#
+#  Copyright (C) 2008 Lars Burgess. All rights reserved.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+module Rhom
+  class RhomDbAdapter
+    
+    @@database = nil
+    
+    class << self
+      def open(dbfile=nil)
+        puts "DB name = " + dbfile.inspect
+        unless @@database or dbfile.nil?
+			db = DbAdapter.new(dbfile)
+			@@database = db
+        end
+		
+      end
+    
+      def close
+        if @@database and not @@database.closed?
+          @@database.close
+          @@database = nil
+        else
+          return false
+        end
+        return true
+      end   
+    
+      # execute a sql statement
+      # optionally, disable the factory processing 
+      # which returns the result array directly
+      def execute_sql
+        result = []
+		  # Make sure we lock the sync engine's mutex
+		  # before we perform a database transaction.
+		  # This prevents concurrency issues.
+		  begin
+			SyncEngine::lock_sync_mutex
+			result = yield
+			SyncEngine::unlock_sync_mutex
+		  rescue Exception => e
+			puts "exception when running query: #{e}"
+			# make sure we unlock even if there's an error!
+			SyncEngine::unlock_sync_mutex
+		  end
+        puts "returned #{result.length.to_s} records..."
+        result
+      end
+    
+      def select_from_table(table=nil,columns=nil,condition=nil,params=nil)
+	    execute_sql { @@database.selectFromTable(table, columns, condition, params) }
+      end
+    
+      def insert_into_table(table=nil,values=nil)
+	    execute_sql { @@database.insertIntoTable(table, values) }
+      end
+    
+      def delete_from_table(table=nil,condition=nil)
+	    execute_sql { @@database.deleteFromTable(table, condition) }
+	  end
+    
+      def delete_all_from_table(table=nil)
+	    execute_sql { @@database.deleteAllFromTable(table) }
+	  end
+    
+      def update_into_table(table=nil,values=nil,condition=nil)
+		execute_sql { @@database.updateIntoTable(table, values, condition) }
+	  end
+    end # class methods
+  end # RhomDbAdapter
+end # Rhom
+
+at_exit do
+	Rhom::RhomDbAdapter::close
+end