arc 0.0.1

data/lib/arc/data_stores/postgres/object_definitions.rb

@@ -0,0 +1,70 @@
+require 'arc/data_stores/abstract/object_definitions'
+
+module Arc
+  module DataStores
+    module ObjectDefinitions
+    
+      class PostgresSchema < Schema
+        def fetch_keys
+          names = @data_store.read("select tablename from pg_tables where schemaname = ANY(current_schemas(false))")
+          names = names.to_a.map { |n| n[:tablename].to_sym }
+        end
+        def fetch_item name
+          PostgresTable.new name, @data_store
+        end
+      end
+
+      class PostgresTable < Table
+        def raw_column_data
+          column_info_query = <<-SQL
+            SELECT  col.attrelid::regclass as table,
+                    col.attname as name,
+                    format_type(col.atttypid, col.atttypmod) as type,
+                    col.attnotnull as not_null,
+                    def.adsrc as default,
+                    ( SELECT d.refobjid
+                      FROM pg_depend d
+                      WHERE col.attrelid = d.refobjid
+                      AND col.attnum = d.refobjsubid
+                      LIMIT 1
+                    ) IS NOT NULL as primary_key
+            FROM pg_attribute as col
+            LEFT JOIN pg_attrdef def
+              ON col.attrelid = def.adrelid
+              AND col.attnum = def.adnum
+            JOIN pg_tables tbl
+              ON col.attrelid::regclass = tbl.tablename::regclass
+            WHERE tbl.schemaname = ANY (current_schemas(false))
+              AND col.attnum > 0
+              AND tbl.tablename = '#{name}'
+            ORDER BY primary_key DESC
+          SQL
+          @data_store.read(column_info_query).to_a.symbolize_keys!
+        end
+        def fetch_keys
+          raw_column_data.map {|c| c[:name].to_sym }
+        end      
+        def fetch_item name
+          return {} unless keys.include? name.to_sym
+          c = raw_column_data.find{|c| c[:name] == name.to_s}
+          PostgresColumn.new @data_store,{
+            name: c[:name],
+            allows_null: c[:not_null] == "f",
+            default: nil,
+            primary_key: c[:primary_key] == "t",
+            type: c[:type]
+          }
+        end
+      end
+
+      class PostgresColumn < Column
+        def type
+          return :varchar if @stype =~ /character varying/
+          return :time if @stype =~ /timestamp/
+          @stype.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/arc/data_stores/postgres/store.rb

@@ -0,0 +1,38 @@
+require 'pg'
+require 'arc/data_stores/postgres/object_definitions'
+
+module Arc
+  module DataStores
+    class PostgresDataStore < AbstractDataStore
+      def read query
+        execute(query).to_a.symbolize_keys!
+      end  
+      def create sql
+        table = sql.match(/\AINSERT into ([^ (]*)/i)[1]
+        sql[-1] = sql[-1] == ';' ? '' : sql[-1]
+        sql += " RETURNING id" unless sql =~ /returning/
+        id = execute(sql).to_a[0].first[1]
+        read("select * from #{table} where id = #{id}")[0]
+      end
+      def execute query
+        with_store { |connection| connection.exec query }
+      end
+      alias :destroy :execute
+      alias :update :execute
+  
+      def schema
+        @schema ||= ObjectDefinitions::PostgresSchema.new self
+      end
+      private
+      def create_connection
+        PGconn.connect({
+          :dbname => @config[:database],
+          :user => @config[:user],
+          :password => @config[:password],
+          :host => @config[:host],
+          :port => @config[:port]
+        })
+      end
+    end
+  end
+end

data/lib/arc/data_stores/sqlite/object_definitions.rb

@@ -0,0 +1,51 @@
+require 'arc/data_stores/abstract/object_definitions'
+
+module Arc
+  module DataStores
+    module ObjectDefinitions
+      class SqliteSchema < Schema
+        def fetch_keys
+          r = @data_store.read <<-SQL
+            SELECT name FROM sqlite_master
+            WHERE type='table' AND name != 'sqlite_sequence';
+          SQL
+          r.map{ |t| t[:name].to_sym }
+        end
+      
+        def fetch_item name
+          SqliteTable.new name, @data_store
+        end
+      end
+    
+      class SqliteTable < Table
+        def raw_column_data
+          @rcd ||= @data_store.read <<-SQL
+            PRAGMA table_info('#{@name}');        
+          SQL
+        end
+        def fetch_keys
+          raw_column_data.map { |c| c[:name].to_sym }
+        end
+        def fetch_item column_name
+          c = raw_column_data.select {|c| c[:name] == column_name.to_s }.first || {}
+          c = {
+            name: c[:name],
+            allows_null: c[:notnull] == 0,
+            default: c[:dflt_value],
+            primary_key: c[:pk] == 1,
+            type: c[:type]
+          }
+          SqliteColumn.new @data_store, c
+        end
+      end
+    
+      class SqliteColumn < Column
+        def type
+          #simplify the type expression to remove length and precision
+          @type ||= @stype.downcase.gsub(/\([\d,]*\)/, '').to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/arc/data_stores/sqlite/store.rb

@@ -0,0 +1,43 @@
+require 'sqlite3'
+require 'arc/data_stores/sqlite/object_definitions'
+
+module Arc
+  module DataStores
+    class SqliteDataStore < AbstractDataStore
+      
+      def read query
+        execute(query).symbolize_keys!
+      end
+      
+      def create sql
+        table = sql.match(/\AINSERT into ([^ (]*)/i)[1]
+        execute sql
+        read("select * from #{table} where id = last_insert_rowid();")[0]
+      end
+      
+      def update sql
+        execute sql
+      end
+      
+      def destroy sql
+        execute sql
+      end
+
+      def execute query
+        with_store do |connection|
+          result = connection.execute(query)
+        end
+      end
+      
+      def schema
+        @schema ||= ObjectDefinitions::SqliteSchema.new self
+      end
+      
+      private
+      def create_connection
+        SQLite3::Database.new @config[:database], :results_as_hash => true
+      end
+            
+    end
+  end
+end

data/lib/arc/quoting.rb

@@ -0,0 +1,91 @@
+require 'date'
+require 'bigdecimal'
+
+module Arc
+  module Quoting
+    class CannotCastValueError < StandardError; end
+    # Quotes the column name. Defaults to no quoting.
+    def quote_column(column_name)
+      "\"#{column_name}\""
+    end
+    alias :quote_column_name :quote_column
+    
+    # Quotes the table name. Defaults to column name quoting.
+    def quote_table(table_name)
+      quote_column_name(table_name)
+    end
+    alias :quote_table_name :quote_table
+          
+    def quote(value, klass=value.class)
+      return quote_nil if (value.nil?)
+      klass = value.class if klass.nil?
+      if value.is_a? Class
+        return quote_string value.name
+      end
+      case klass
+      when String, Symbol
+        method = "quote_#{klass.to_s}"
+        return send method, value if respond_to? method, :include_private => true
+      when Arc::DataStores::ObjectDefinitions::Column
+        method = "quote_#{Arc::Casting::TYPES[klass.type.to_sym]}"
+        return send(method, value)
+      else
+        while klass.name do
+          method = "quote_#{klass.name.downcase.gsub(/class/,'')}"
+          return send method, value if respond_to? method, :include_private => true
+          klass = klass.superclass
+        end
+      end
+      raise CannotCastValueError, "Unable to cast #{value}"
+    end
+    
+    private
+    # Quotes a string, escaping any ' (single quote) and \ (backslash)
+    # characters.
+    def quote_symbol s
+      quote_string s.to_s
+    end
+    def quote_string(s)
+      "'#{s.gsub(/\\/, '\&\&').gsub(/'/, "''")}'"
+    end
+    def quote_true value=true
+      quote_string 't'
+    end
+    def quote_boolean value
+      value ? quote_true : quote_false
+    end
+    def quote_false value=false
+      quote_string 'f'
+    end
+    def quote_date(value)
+      return quote_string value if value.is_a? String
+      quote_string "#{value.strftime '%Y-%m-%d'}"
+    end
+    def quote_time value
+      return quote_string value if value.is_a? String
+      quote_string "#{value.strftime '%Y-%m-%d %H:%M:%S'}"
+    end
+    def quote_numeric value
+      value.to_s
+    end
+    def quote_integer value
+      quote_numeric value.to_i
+    end
+    def quote_bigdecimal value
+      return value if value.is_a? String
+      value.to_s 'F'
+    end
+    def quote_nil(value=nil)
+      'NULL'
+    end
+    def quote_binary value
+      value.gsub!(/\0|\%/n) do |byte|
+        case byte
+          when "\0" then "%00"
+          when '%'  then "%25"
+        end
+      end
+      quote_string value        
+    end
+  end
+end

data/lib/arc/reactor.rb

@@ -0,0 +1,29 @@
+module Arc
+  module Reactor  
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    def data_store
+      self.class.data_store
+    end
+    
+    module ClassMethods
+      def connect(config)
+        @data_store = Arc::DataStores[config[:adapter]].new config
+      end      
+      def data_store
+        @data_store
+      end
+    end
+    
+  end    
+end
+
+#Example Use:
+# class MyReactorBase
+#   include Arc::Reactor
+#   connect("hello world")
+# end
+

data/lib/arc/version.rb

@@ -0,0 +1,3 @@
+module Arc
+  VERSION = "0.0.1"
+end

data/spec/casting_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'arc/casting'
+
+module Arc
+  describe Casting do
+    before :all do
+      @caster = Class.new { include Casting }.new
+    end    
+    describe '#cast' do
+      
+      it 'casts a string to an integer' do
+        value = @caster.cast "1", :integer
+        value.should == 1
+        value = @caster.cast "1", :int
+        value.should == 1
+      end
+      
+      it 'casts a string to a float' do
+        value = @caster.cast "1.1", :float
+        value.should == 1.1
+      end
+      
+      it 'casts a string to a time' do
+        time = Time.now.round(0)
+        value = @caster.cast time.to_s, :time
+        value.should == time
+        value = @caster.cast time.to_s, :datetime
+        value.should == time        
+      end
+      
+      it 'casts a string to a date' do
+        date = Date.today
+        value = @caster.cast date.to_s, :date
+        value.should == date
+      end
+      
+      it 'unescapes binary data' do
+        binary = "%25%00\\\\"
+        value = @caster.cast binary, :binary
+        value.should == "%\0\\"
+      end
+      
+      it "casts 'true'" do
+        truths = ['true', true, 't', '1', 1]
+        truths.each do |truth|
+          value = @caster.cast truth, :bool
+          value.should be_true
+          value = @caster.cast truth, :boolean
+          value.should be_true 
+          value = @caster.cast true, :bit
+          value.should be_true
+        end
+      end
+      
+      it "casts 'false'" do
+        lies = ['false', false, 'f', '0', 0]
+        lies.each do |lie|
+          value = @caster.cast lie, :bool
+          value.should be_false
+          value = @caster.cast lie, :boolean
+          value.should be_false 
+          value = @caster.cast lie, :bit
+          value.should be_false 
+        end
+      end
+      
+      it 'defaults to string if no casting method is found' do
+        value = @caster.cast 'superman', :awesome
+        value.should == 'superman'
+      end
+      
+    end
+  end
+end

data/spec/data_stores/abstract/arel_compatibility_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Arc
+  module DataStores
+    describe ArelCompatibility do
+      it '#specifies which arel visitor to use' do
+        ArcTest.with_store do |s|
+          Arel::Visitors.for s
+        end
+      end      
+      it '#responds to #connection_pool#spec#config' do
+        ArcTest.with_store do |s|
+          s.connection_pool.spec.config[:adapter].should == ArcTest.config_key.to_s
+        end
+      end
+      it 'responds to #with_connection and yields an object which has an execute method' do
+        ArcTest.with_store do |s|
+          s.with_connection do |connection|
+            s.connection.should respond_to(:execute)
+          end
+        end
+      end
+      it 'provides a visitor at #connection.visitor' do
+        ArcTest.with_store do |s|
+          s.stub!(:visitor).and_return("lol")
+          s.connection.visitor.should == "lol"
+        end
+      end
+      it "aliases #quote_table to #quote_table_name" do
+        ArcTest.with_store do |s|
+          s.method(:quote_table).should == s.method(:quote_table_name)
+        end
+      end
+      it 'aliases quote_column to #quote_column_name' do
+        ArcTest.with_store do |s|
+          s.method(:quote_column).should == s.method(:quote_column_name)
+        end
+      end
+      it 'provides a table_exists? method' do
+        ArcTest.with_store do |s|
+          s.table_exists?(:superheros).should be_true
+        end
+      end
+      it 'provides a hashlike object at #connection_pool.columns_hash' do
+        ArcTest.with_store do |s|
+          s.connection_pool.columns_hash.should be(s)
+        end
+      end
+      it 'responds to primary_key given a table name' do
+        ArcTest.with_store do |s|
+          s.connection.primary_key(:superheros).should be(:id)
+        end
+      end
+      it 'should quote a hash' do
+        ArcTest.with_store do |s|
+          hash = {:a => :b}
+          s.quote_hash(hash).should == "'#{hash.to_yaml}'"
+        end
+      end
+      
+    end
+  end
+end