dbagile 0.0.1

data/lib/dbagile/restful/middleware/get.rb

@@ -0,0 +1,27 @@
+module DbAgile
+  module Restful
+    class Middleware
+      module Get
+      
+        # Implements GET access of the restful interface
+        def get(env)
+          request = Rack::Request.new(env)
+          decode(env) do |connection, table, format|
+            # Compute the projection on query string
+            heading = connection.heading(table)
+            projection = params_to_tuple(request.GET, heading)
+        
+            # Retrieve dataset
+            columns = connection.column_names(table)
+            dataset = connection.dataset(table, projection)
+
+            # Make output now
+            format ||= :json 
+            [format, to_xxx_enumerable(format, dataset, columns)]
+          end
+        end
+      
+      end # module Get
+    end # class Middleware
+  end # module Restful
+end # module Facts

data/lib/dbagile/restful/middleware/one_database.rb

@@ -0,0 +1,82 @@
+module DbAgile
+  module Restful
+    class Middleware
+      # 
+      # Rack middleware that provide access to a database using a database 
+      # instance (DbAgile::Core::Database)
+      #
+      class OneDatabase
+        include Middleware::Utils
+        include Middleware::Get
+        include Middleware::Post
+        include Middleware::Delete
+        
+        # Database instance
+        attr_reader :database
+        
+        # Creates a middleware instance
+        def initialize(database)
+          raise ArgumentError unless database.kind_of?(DbAgile::Core::Database)
+          @database = database
+        end
+        
+        # Decodes a path and yield the block with a connection and the 
+        # requested format
+        def decode(env)
+          case env['PATH_INFO'].strip[1..-1]
+            when ''
+              _copyright_(env)
+            when /(\w+)(\.(\w+))?$/
+              table = $1.to_sym
+            
+              # Handle format
+              format = nil
+              if $2
+                format = known_extension?($2)
+                return _404_(env) unless format
+              end
+            
+              format, body = database.with_connection do |connection|
+                yield(connection, table, format) 
+              end
+              
+              content_type = DbAgile::IO::FORMAT_TO_CONTENT_TYPE[format]
+              _200_(env, content_type, body)
+            else
+              _404_(env)
+          end
+        rescue DbAgile::InvalidDatabaseName,
+               DbAgile::NoSuchDatabaseError,
+               DbAgile::NoSuchTableError => ex
+          _404_(env, ex)
+        rescue DbAgile::Error, Sequel::Error => ex
+          if ex.message =~ /exist/
+            _404_(env)
+          else
+            raise
+          end
+        end
+      
+        # Rack handler
+        def call(env)
+          method = env['REQUEST_METHOD'].downcase.to_sym
+          if self.respond_to?(method)
+            result = self.send(method, env)
+          else
+            puts "Unsupported restful method #{env['REQUEST_METHOD']}"
+            [
+              500, 
+              {'Content-Type' => 'text/plain'},
+              ["Unsupported restful method #{env['REQUEST_METHOD']}"]
+            ]
+          end
+        rescue Exception => ex
+          puts ex.message
+          puts ex.backtrace.join("\n")
+          [500, {'Content-Type' => 'text/plain'}, [ex.message]]
+        end
+        
+      end # class OneDatabase
+    end # class Middleware
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/restful/middleware/post.rb

@@ -0,0 +1,23 @@
+module DbAgile
+  module Restful
+    class Middleware
+      module Post
+      
+        # Implements POST access of the restful interface
+        def post(env)
+          request = Rack::Request.new(env)
+          decode(env) do |connection, table, format|
+            format = :json if format.nil?
+            heading = connection.heading(table)
+            tuple = params_to_tuple(request.POST, heading)
+            inserted = connection.transaction do |t|
+              t.insert(table, tuple)
+            end
+            [format, to_xxx_enumerable(format, [ inserted ], tuple.keys)]
+          end
+        end
+      
+      end # module Get
+    end # class Middleware
+  end # module Restful
+end # module Facts

data/lib/dbagile/restful/middleware/utils.rb

@@ -0,0 +1,65 @@
+module DbAgile
+  module Restful
+    class Middleware
+      module Utils
+        include ::DbAgile::IO
+      
+        # Converts get parameters to a tuple for projection
+        def params_to_tuple(params, heading)
+          copy = {}
+          params.each_pair{|k, v| 
+            k = k.to_sym
+            next unless heading.key?(k)
+            copy[k] = SByC::TypeSystem::Ruby::coerce(v, heading[k])
+          }
+          copy
+        end
+      
+        # Returns a copyright response
+        def _copyright_(env)
+          [
+            200, 
+            {'Content-Type' => 'text/plain'}, 
+            [ "dba #{DbAgile::VERSION} (c) 2010, Bernard Lambeau" ]
+          ]
+        end
+      
+        # Returns a 404 response
+        def _404_(env, ex = nil)
+          [
+            404, 
+            {'Content-Type' => 'text/plain'},
+            [ "Not found #{env['PATH_INFO']}: " ] + (ex.nil? ? [] : [ ex.message ])
+          ]
+        end
+      
+        # Returns a 200 response for a given format
+        def _200_(env, type, result)
+          [
+            200,
+            {'Content-Type' => type},
+            result
+          ]
+        end
+        
+        # Returns a 500 response
+        def _500_(env, message)
+          [
+            500, 
+            {'Content-Type' => 'text/plain'}, 
+            [ message ]
+          ]
+        end
+      
+        # Converts a dataset-like object to an enumerable rack result
+        def to_xxx_enumerable(format, dataset, columns)
+          buffer = StringIO.new
+          method = "to_#{format}".to_sym
+          DbAgile::IO.send(method, dataset, columns, buffer)
+          [ buffer.string ]
+        end
+
+      end # module Utils
+    end # class Middleware
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/restful/middleware.rb

@@ -0,0 +1,54 @@
+require 'stringio'
+require 'json'
+require 'dbagile'
+require 'dbagile/restful/middleware/utils'
+require 'dbagile/restful/middleware/get'
+require 'dbagile/restful/middleware/post'
+require 'dbagile/restful/middleware/delete'
+require 'dbagile/restful/middleware/one_database'
+module DbAgile
+  module Restful
+    class Middleware
+      include Middleware::Utils
+    
+      # Environment
+      attr_reader :environment
+      
+      # OneDatabase delegates
+      attr_reader :delegates
+    
+      # Creates a Restful handler
+      def initialize(environment = DbAgile::default_environment, &block)
+        raise "Environment may not be nil" if environment.nil?
+        block.call(environment) if block
+        @environment = environment
+        _install
+      end
+      
+      # Installs the delegates
+      def _install
+        @delegates = {}
+        environment.repository.each{|db|
+          @delegates[db.name] = Middleware::OneDatabase.new(db)
+        }
+      end
+      
+      # Delegated according to the path
+      def call(env)
+        env['PATH_INFO'] =~ /^\/(\w+)(.*)$/
+        if $1
+          if delegates.key?($1.to_sym)
+            env['PATH_INFO'] = $2
+            delegates[$1.to_sym].call(env)
+          else
+            _404_(env)
+          end
+        else
+          _copyright_(env)
+        end
+      end
+     
+      private :_install
+    end # class Middleware
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/restful/server.rb

@@ -0,0 +1,65 @@
+if RUBY_VERSION == "1.8.6"
+  gem 'rack', "= 1.1.0"
+  require 'rack'
+else
+  gem 'rack', ">= 1.1.0"
+  require 'rack'
+end
+require 'dbagile/restful/middleware'
+require 'uri'
+require "net/http"
+require 'webrick'
+module DbAgile
+  module Restful
+    class Server
+      
+      # Default Rack options for restful server and client
+      DEFAULT_RACK_OPTIONS = {:Port => 8711, :Host => "127.0.0.1", :AccessLog => []}
+      
+      # Server options
+      attr_reader :options
+    
+      # Creates a server instance
+      def initialize(environment, options = DEFAULT_RACK_OPTIONS)
+        raise "Environment may not be nil" if environment.nil?
+        @environment = environment
+        @options = options
+      end
+    
+      # Returns the server uri given by options
+      def uri
+        URI::parse("http://#{options[:Host]}:#{options[:Port]}/")
+      end
+    
+      # Starts the server inside a thread
+      def start
+        myself, env  = self, @environment
+        rack_server  = ::Rack::Handler::default
+        rack_app     = ::Rack::Builder.new{ run DbAgile::Restful::Middleware.new(env) }
+        thread       = Thread.new(rack_server, rack_app, options.dup){|s,a,o| 
+          s.run(a, o){|server| @server = server}
+        }
+        
+        # Wait until the server is loaded
+        try, ok, res = 0, false, nil
+        begin
+          res = Net::HTTP.get(uri)
+          ok = true
+        rescue Errno::ECONNREFUSED => ex
+          sleep 0.3
+        end until (ok or (try += 1)>10)
+        raise "Unable to connect to server" if try >= 10
+        
+        @environment.say("Have a look at #{uri}")
+        thread
+      end
+      
+      # Stops the server
+      def stop
+        @server.shutdown if @server.respond_to?(:shutdown)
+        @server = nil
+      end
+      
+    end # class Server
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/restful.rb

@@ -0,0 +1,9 @@
+module DbAgile
+  #
+  # Marker module for the Restful interface.
+  #
+  # @see http://blambeau.github.com/dbagile/restful
+  #
+  module Restful
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/robustness/dependencies.rb

@@ -0,0 +1,36 @@
+module DbAgile
+  module Robustness
+    module Dependencies
+
+      # Raises when a dependency is missing
+      class ::DbAgile::DependencyError < ::DbAgile::Error; end
+
+      # Asserts that a standard library 
+      def has_stdlib!(util_name, msg = nil)
+        require util_name
+      rescue StandardError => ex
+        if msg.nil?
+          msg = "DbAgile requires #{util_name} but failed to load it" 
+        end
+        msg = "#{msg}\n#{ex.message}"
+        raise DbAgile::DependencyError, msg, ex.backtrace
+      end
+      
+      # Asserts that a gem exists and is loaded
+      def has_gem!(gem_name, gem_version = nil, msg = nil)
+        require 'rubygems'
+        gem gem_name, gem_version
+        require gem_name
+      rescue StandardError => ex
+        if msg.nil?
+          msg = gem_version.nil? ? gem_name : "#{gem_name} (#{gem_version})"
+          msg = "DbAgile requires #{msg} but failed to load it" 
+        end
+        msg = "#{msg}\n#{ex.message}"
+        raise DbAgile::DependencyError, msg, ex.backtrace
+      end
+      
+    end # module Dependencies
+    extend(Dependencies)
+  end # module Robustness
+end # module DbAgile

data/lib/dbagile/robustness/file_system.rb

@@ -0,0 +1,53 @@
+module DbAgile
+  module Robustness
+    module FileSystem
+      
+      # Asserts that a directory exists, is readable and writable
+      def valid_rw_directory!(dir, 
+                              msg = "Unable to access #{dir} in read/write", 
+                              error_class = IOError)
+        unless File.directory?(dir) &&
+               File.readable?(dir) &&
+               File.writable?(dir)
+          raise error_class, msg, caller
+        end
+        dir
+      end
+
+      # Asserts that a file exists, is readable and writable
+      def valid_rw_file!(file, 
+                         msg = "Unable to access #{file} in read/write", 
+                         error_class = IOError)
+        unless File.file?(file) &&
+               File.readable?(file) &&
+               File.writable?(file)
+          raise error_class, msg, caller
+        end
+        file
+      end
+      
+      # Asserts that a file exists and is readable.
+      def valid_r_file!(file, 
+                        msg = "Unable to access #{file} in read", 
+                        error_class = IOError)
+        unless File.file?(file) &&
+               File.readable?(file)
+          raise error_class, msg, caller
+        end
+        file
+      end
+      
+      # Asserts that a directory does not exists
+      def unexisting_directory!(dir, 
+                                msg = "Directory #{dir} already exists, use --force", 
+                                error_class = IOError)
+        if File.exists?(dir)
+          raise error_class, msg, caller
+        end
+        dir
+      end
+      
+    end # module FileSystem
+    extend(FileSystem)
+  end # module Robustness
+end # module DbAgile

data/lib/dbagile/robustness.rb

@@ -0,0 +1,14 @@
+module DbAgile
+  
+  # Main class of all DbAgile errors
+  class Error < StandardError; end
+  
+  # Raised when something goes really wrong (a bug, typically)
+  class InternalError < DbAgile::Error; end
+  
+  # Some internal assumption failed
+  class AssumptionFailedError < DbAgile::InternalError; end
+  
+end
+require 'dbagile/robustness/file_system'
+require 'dbagile/robustness/dependencies'

data/lib/dbagile/tools/file_system.rb

@@ -0,0 +1,24 @@
+module DbAgile
+  module FileSystemTools
+    
+    # Returns a friendly path for display
+    def friendly_path(path, from)
+      from, path = Pathname.new(from), Pathname.new(path)
+      if path.to_s[0...from.to_s.length] == from.to_s
+        "~/#{path.relative_path_from(from)}"
+      else
+        nil
+      end
+    end
+    
+    # Returns a friendly path, no matter what happens
+    def friendly_path!(path)
+      friendly_path(path, ENV['HOME']) or
+      friendly_path(path, File.expand_path('.')) or
+      path
+    end
+    
+    extend(FileSystemTools)
+  end # module FileSystemTools
+end # module DbAgile
+    

data/lib/dbagile/tools/math.rb

@@ -0,0 +1,11 @@
+module DbAgile
+  module MathTools
+    
+    # Returns x if x > y, y otherwise
+    def max(x, y)
+      x > y ? x : y
+    end
+
+    extend(MathTools)
+  end # module StringTools
+end # module DbAgile

data/lib/dbagile/tools/ordered_hash.rb

@@ -0,0 +1,39 @@
+module DbAgile
+  module Tools
+    class OrderedHash
+      
+      # Decorates a hash as an ordered hash
+      def initialize(hash = {})
+        @hash = hash
+        @keys = hash.keys
+      end
+      
+      # Delegated to hash
+      def method_missing(name, *args, &block)
+        @hash.send(name, *args, &block)
+        @keys = (@keys & @hash.keys)
+      end
+      
+      # Sets a (name,value) pair
+      def []=(name, value)
+        @hash[name] = value
+        unless @keys.include?(name)
+          @keys << name
+        end
+        value
+      end
+      
+      # Puts as YAML, maintaining order
+      def to_yaml(opts = {})
+        YAML::quick_emit(self, opts){|out|
+          out.map("tag:yaml.org,2002:map") do |map|
+            @keys.each{|key|
+              map.add(key.to_s, @hash[key])
+            }
+          end
+        }
+      end
+      
+    end # class OrderedHash
+  end # module Tools
+end # module DbAgile

data/lib/dbagile/tools/ruby.rb

@@ -0,0 +1,78 @@
+module DbAgile
+  module RubyTools
+    
+    # Returns the parent module of a class
+    def parent_module(clazz)
+      name = clazz.name
+      if name =~ /^(.*?)::([^:]+)$/
+        Kernel.eval($1)
+      else
+        nil
+      end
+    end
+    
+    # Returns the unqualified name of a class
+    def class_unqualified_name(clazz)
+      name = clazz.name
+      if name =~ /::([^:]+)$/
+        $1
+      else
+        name
+      end
+    end
+    alias :unqualified_class_name :class_unqualified_name
+    
+    # Makes a call to a block that accepts optional arguments
+    def optional_args_block_call(block, args)
+      if RUBY_VERSION >= "1.9.0"
+        if block.arity == 0
+          block.call
+        else
+          block.call(*args)
+        end
+      else
+        block.call(*args)
+      end
+    end
+    
+    # Extracts the rdoc of a given ruby file source
+    def extract_file_rdoc(file)
+      source, doc, started = File.read(file), "", false
+      source.each_line{|line|
+        if /^\s*[#]/ =~ line
+          doc << line
+          started = true
+        elsif started
+          break
+        end 
+      }
+      doc.gsub(/^\s*[#] ?/, "")
+    end
+    
+    # Splits a text obtained through extract_file_rdoc into paragraphs
+    def rdoc_paragraphs(rdoc_text)
+      paragraphs, current = [], ""
+      rdoc_text.each_line do |s|
+        if s.strip.empty?
+          unless current.strip.empty?
+            paragraphs << current 
+          end
+          current = ""
+        else
+          current << s
+        end
+      end
+      unless current.strip.empty?
+        paragraphs << current 
+      end
+      paragraphs
+    end
+    
+    # Convenient method for <code>rdoc_paragraphs(extract_file_rdoc(file))</code>
+    def rdoc_file_paragraphs(file)
+      rdoc_paragraphs(extract_file_rdoc(file))
+    end
+    
+    extend(RubyTools)
+  end # module RubyTools
+end # module DbAgile

data/lib/dbagile/tools/string.rb

@@ -0,0 +1,6 @@
+module DbAgile
+  module StringTools
+    
+
+  end # module StringTools
+end # module DbAgile

data/lib/dbagile/tools/tuple.rb

@@ -0,0 +1,49 @@
+module DbAgile
+  module Tools
+    module Tuple
+      
+      # Returns the heading of a given tuple
+      def tuple_heading(tuple)
+        heading = {}
+        tuple.each_pair{|name, value| heading[name] = value.class}
+        heading
+      end
+      
+      # Checks a tuple heading, displaying a warning message on the 
+      # environment if something goes bad...
+      def check_tuple_heading(heading, environment)
+        heading.each_pair{|k,v|
+          if NilClass == v
+            environment.say("WARNING: NilClass in heading (type inference failure), using String")
+            heading[k] = String
+          elsif !DbAgile::RECOGNIZED_DOMAINS.include?(v)
+            environment.say("WARNING: Unrecognized domain #{v} in heading, using String")
+            heading[k] = String
+          end
+        }
+        heading
+      end
+      
+      # Projects a tuple over some columns
+      def tuple_project(tuple, columns)
+        proj = {}
+        columns.collect{|col| proj[col] = tuple[col]}
+        proj
+      end
+      
+      # Extract the key/value pairs that form a key on a tuple, given 
+      # keys information. Returns tuple if no such better tuple can be found.
+      def tuple_key(tuple, keys)
+        return tuple if keys.nil?
+        key = keys.find{|k| k.all?{|a| !tuple[a].nil? }}
+        key.nil? ? tuple : tuple_project(tuple, key)
+      end
+      
+      # Converts a tuple to a query string
+      def tuple_to_querystring(tuple)
+        tuple.collect{|k,v| "#{CGI::escape(k.to_s)}=#{CGI::escape(v.to_s)}"}.reverse.join('&')
+      end
+      
+    end # module Tools
+  end # class Adapter
+end # module DbAgile

data/lib/dbagile/tools.rb

@@ -0,0 +1,6 @@
+require 'dbagile/tools/ruby'
+require 'dbagile/tools/math'
+require 'dbagile/tools/string'
+require 'dbagile/tools/tuple'
+require 'dbagile/tools/ordered_hash'
+require 'dbagile/tools/file_system'