dm-frontbase-adapter 1.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+nbproject

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dm-frontbase-adapter.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dm-frontbase-adapter.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+
+Gem::Specification.new do |s|
+  s.name        = "dm-frontbase-adapter"
+  s.version     = '1.1.0'
+  s.authors     = ["zapo"]
+  s.email       = ["antoine.niek@supinfo.com"]
+  s.homepage    = ""
+  s.summary     = %q{gem summary}
+  s.description = %q{gem description}
+
+  s.rubyforge_project = "dm-frontbase-adapter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency 'ruby-frontbase'
+  s.add_dependency "dm-core"
+  s.add_dependency "dm-validations"
+  s.add_dependency "dm-types"
+end

data/lib/dm-frontbase-adapter.rb

@@ -0,0 +1,14 @@
+require 'dm-core'
+
+class FrontbaseAdapter < ::DataMapper::Adapters::AbstractAdapter
+  Inflector = ::DataMapper.const_defined?(:Inflector) ? ::DataMapper::Inflector : ::Extlib::Inflection
+end
+
+
+# add our adapter to datamapper adapter list
+
+::DataMapper::Adapters::FrontbaseAdapter = FrontbaseAdapter
+::DataMapper::Adapters.const_added(:FrontbaseAdapter)
+
+require 'frontbase'
+require "dm-frontbase-adapter/adapter"

data/lib/dm-frontbase-adapter/adapter.rb

@@ -0,0 +1,115 @@
+require 'dm-frontbase-adapter/connection'
+require 'dm-frontbase-adapter/sql_query'
+
+
+class FrontbaseAdapter < ::DataMapper::Adapters::AbstractAdapter
+  
+  # cache data per operation accessor
+  attr_accessor :data
+  
+  # frontbase operations accessor
+  attr_accessor :models_operations
+
+  def field_naming_convention
+     proc {|property| property.name.to_s }
+  end
+  
+  def resource_naming_convention
+    proc {|resource| resource.to_s }
+  end
+  
+  def initialize(name, options)
+
+    # store our options in a hash :sym => value
+    @options = options.inject({}) {|memo, (k,v)| memo[k.to_sym] = v; memo}
+    @options[:encoding] ||= 'iso-8859-1'
+    
+    # initialize abstract adapter
+    super(name, @options)
+  end
+  
+  def log msg
+    DataMapper.logger.info "FrontbaseAdapter: #{msg}"
+  end
+
+  def connection
+    @connection ||= FrontbaseAdapter::Connection.new(@options)
+  end
+
+  def with_connection &block
+    block.call(connection) if block
+  rescue
+    raise $!
+  ensure
+    connection.close
+  end
+
+  # Simple read method that take a DataMapper::Query object that represent the query
+  # Returns a filtered data hash built from the query model operation returned xml
+  def read(query)
+
+    properties = query.fields
+    
+    statement = SQLQuery.new(query, :select).to_s
+    
+    log statement
+    
+    records = with_connection { |connection|
+      response_to_a(connection.query(statement), properties)
+    }
+    
+    query.filter_records(records)
+  end
+  
+  def response_to_a response, props = nil
+    columns = response.columns
+    result = response.result 
+
+    result.inject([]) do |arr, record|
+      
+      record = Hash[*columns.zip(record).flatten].inject({}) do |hash, (column, value)| 
+        if props && (prop = props.find {|prop| prop.field.to_sym == column.to_sym })
+          
+          case
+          when prop.is_a?(::DataMapper::Property::Boolean)
+            value = case
+            when [1.0, 1, true, "true"].include?(value)
+              true
+            else
+              false
+            end
+          when prop.kind_of?(::DataMapper::Property::String)
+            value = value.to_s.force_encoding('ISO-8859-1').encode('UTF-8', :undef => :replace, :invalid => :replace)
+          end
+          
+          value = prop.typecast(value)
+          
+        elsif value.kind_of? String
+          value = value.to_s.force_encoding('ISO-8859-1').encode('UTF-8', :undef => :replace, :invalid => :replace)
+        end
+        
+        hash[column] = value
+        hash
+      end
+      arr << record
+      arr
+    end
+  end
+  
+  def describe storage_name
+    with_connection do |connection|
+      connection.describe storage_name
+    end
+  end
+  
+  def show_tables
+    with_connection do |connection|
+      
+      stmt = 'SELECT * FROM INFORMATION_SCHEMA.SCHEMATA T0, INFORMATION_SCHEMA.TABLES T1 WHERE T0."SCHEMA_PK" = T1."SCHEMA_PK";'
+      log stmt
+
+      records = response_to_a(connection.query(stmt))
+      records.find_all {|record| record[:SCHEMA_NAME] != 'INFORMATION SCHEMA' && record[:TABLE_TYPE] == 'BASE_TABLE'}.map {|record| record[:TABLE_NAME]}
+    end
+  end
+end

data/lib/dm-frontbase-adapter/connection.rb

@@ -0,0 +1,74 @@
+class FrontbaseAdapter < ::DataMapper::Adapters::AbstractAdapter
+  
+  # Connection wrapper
+
+  class Connection
+    
+    def initialize(options)
+      default = {
+        :host       => 'localhost',
+        :port       => -1,
+        :user       => '',
+        :password   => '',
+        :dbpassword => '',
+        :database   => '',
+      }
+      
+      @options = default.merge(options)
+      connection
+    end
+    
+    def connection
+      unless @connection 
+        @connection = FBSQL_Connect.new(
+          @options[:host],
+          @options[:port], 
+          @options[:database], 
+          @options[:user], 
+          @options[:password], 
+          @options[:dbpassword]
+        )
+        @connection.input_charset  = encoding_map['UTF-8']
+        @connection.output_charset = encoding_map['ISO-8859-1']
+      end
+      
+      @connection
+    end
+    
+    def query str
+      connection.query str
+    end
+    
+    def encoding_map
+      {
+        'ISO-8859-1' => FBSQL_Connect::FBC_ISO8859_1,
+        'UTF-8'      => FBSQL_Connect::FBC_UTF_8
+      }
+    end
+    
+    def describe(table)
+      sql = %[SELECT T3."COLUMN_NAME" AS NAME, T4."DATA_TYPE" FROM 
+        INFORMATION_SCHEMA.CATALOGS T0, 
+        INFORMATION_SCHEMA.SCHEMATA T1, 
+        INFORMATION_SCHEMA.TABLES T2, 
+        INFORMATION_SCHEMA.COLUMNS T3,
+        INFORMATION_SCHEMA.DATA_TYPE_DESCRIPTOR T4 
+
+        WHERE 
+          T0."CATALOG_PK" = T1."CATALOG_PK" AND 
+          T1."SCHEMA_PK" = T2."SCHEMA_PK" AND 
+          T2."TABLE_PK" = T3."TABLE_PK" AND 
+          T3."COLUMN_PK" = T4."COLUMN_NAME_PK" AND 
+          T1."SCHEMA_NAME" LIKE CURRENT_SCHEMA AND
+          T2."TABLE_NAME" LIKE '#{table}';]
+      connection.query(sql)
+    end
+    
+    def close
+      connection.close
+      @connection = nil
+    end
+
+  end
+  
+end

data/lib/dm-frontbase-adapter/sql_query.rb

@@ -0,0 +1,142 @@
+class FrontbaseAdapter
+  class SQLQuery
+    
+    include DataMapper::Query::Conditions
+    
+    attr_reader :conditions, :order, :type, :from, :columns
+    
+    def initialize(query, type)
+      @type       = type
+      @query      = query
+      
+      setup_statement
+    end
+    
+    def setup_statement
+            
+      @conditions = (@query.conditions) ?
+        conditions_statement(@query.conditions) : ''
+      
+      @order      = (@query.order      && !@query.order.empty?) ?
+        order_statement(@query.order) : ''
+      
+      @columns    = columns_statement @query.fields
+      
+      @from       = quote_name(@query.model.storage_name(@query.repository.name))
+    end
+    
+    def order_statement orders
+      orders.map {|o| "#{o.target.field} #{o.operator.to_s.upcase}" }.join(', ')
+    end
+    
+    def columns_statement properties
+      properties.map {|property| property_to_column_name(property) }.join(', ')
+    end
+    
+    def to_s
+      
+      statement = ''
+      
+      if @type == :select
+        statement <<  "SELECT   #{columns}"
+        statement << " FROM     #{from}"
+        statement << " WHERE    #{conditions}"  unless conditions.to_s.empty?
+        statement << " ORDER BY #{order}"       unless order.empty?
+        statement << ";"
+
+        if @query.limit || (@query.limit && @query.offset > 0)
+
+          replacement = "SELECT TOP(" 
+          replacement << "#{@query.offset.to_i}," if @query.limit && @query.offset > 0
+          replacement << "#{@query.limit.to_i}"   if @query.limit 
+          replacement << ")"
+
+          statement.gsub!('SELECT', replacement)
+        end
+      end
+
+      statement
+    end
+    
+    def conditions_statement(conditions)
+      case conditions
+        when AbstractOperation  then  operation_statement(conditions)
+        when AbstractComparison then comparison_statement(conditions)
+      end
+    end
+    
+    def operation_statement(operation)
+      case operation
+        when NotOperation then "NOT(#{conditions_statement(operation.first)})"
+        when AndOperation then "(#{operation.map {|op| conditions_statement(op) }.join(' AND ')})"
+        when OrOperation  then "(#{operation.map {|op| conditions_statement(op) }.join(' OR ')})"
+      end
+    end
+
+    def comparison_statement(comparison)
+      
+      return conditions_statement(comparison.foreign_key_mapping) if comparison.relationship?
+      
+      value   = comparison.value
+      subject = property_to_column_name comparison.subject
+
+      operator = case comparison
+        when EqualToComparison              then '='
+        when GreaterThanComparison          then '>'
+        when LessThanComparison             then '<'
+        when GreaterThanOrEqualToComparison then '>='
+        when LessThanOrEqualToComparison    then '<='
+        when LikeComparison                 then 'LIKE'
+        when InclusionComparison            then include_operator(value)
+      end
+
+      "#{subject} #{operator} #{quote_value(value, comparison.subject)}"
+    end
+    
+    def include_operator(value)
+      case value
+      when Array then 'IN'
+      when Range then 'BETWEEN'
+      end
+    end
+
+    def property_to_column_name(prop)
+      res = case prop
+      when DataMapper::Property
+        quote_name(prop.field)
+      when DataMapper::Query::Path
+        rels = prop.relationships
+        names = rels.map {|r| storage_name(r, @query.repository) }.join(".")
+        "#{names}.#{quote_name(prop.field)}"
+      end
+
+      res
+    end
+    
+    def quote_name(name)
+      "\"#{name.gsub('"', '""')}\""
+    end
+
+    def storage_name(rel, repository)
+      rel.parent_model.storage_name(repository.name)
+    end
+
+
+    def quote_value(value, property)
+      if property.kind_of? DataMapper::Property::Boolean
+        return value == DataMapper::Property::Boolean::TRUE ? 'TRUE' : 'FALSE'
+      end
+
+      case
+      when value.kind_of?(Array)
+        "(#{value.map {|v| quote_value(v, property)}.join(", ")})"
+      when value.kind_of?(NilClass)
+        "NULL"
+      when value.kind_of?(String)
+        "'#{value.to_s.gsub(/'/, "\\'").gsub(/\\/, %{\\\\})}'"
+      else
+        value.to_s
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: dm-frontbase-adapter
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+  prerelease: 
+platform: ruby
+authors:
+- zapo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-frontbase
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dm-core
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dm-validations
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dm-types
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: gem description
+email:
+- antoine.niek@supinfo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- dm-frontbase-adapter.gemspec
+- lib/dm-frontbase-adapter.rb
+- lib/dm-frontbase-adapter/adapter.rb
+- lib/dm-frontbase-adapter/connection.rb
+- lib/dm-frontbase-adapter/sql_query.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: dm-frontbase-adapter
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: gem summary
+test_files: []