dbagile 0.0.1

data/lib/dbagile/io/json.rb

@@ -0,0 +1,41 @@
+module DbAgile
+  module IO
+    module JSON
+      extend IO::TypeSafe
+      
+      # 
+      # Outputs some data as a JSON string
+      #
+      # @return [...] the buffer itself
+      #
+      def to_json(data, columns = nil, buffer = "", options = {})
+        require "json"
+        pretty, first = options[:pretty], true
+        buffer << (pretty ? "[\n" : "[")
+        with_type_safe_relation(data, options) do |tuple|
+          buffer << (pretty ? ",\n" : ",") unless first
+          if pretty
+            buffer << ::JSON::pretty_generate(tuple)
+          else
+            buffer << ::JSON::fast_generate(tuple)
+          end
+          first = false
+        end
+        buffer << (pretty ? "\n]" : "]")
+        buffer
+      end
+      module_function :to_json
+      
+      #
+      # Loads some data from a json input. If a block is given, yields it with
+      # each tuple in turn and returns nil. Otherwise returns an array of tuples.
+      #
+      def from_json(input, options = {}, &block)
+        require "json"
+        from_typesafe_xxx(::JSON::load(input), options, &block)
+      end
+      module_function :from_json
+      
+    end # module JSON
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/pretty_table.rb

@@ -0,0 +1,128 @@
+#
+# This file has been originally copied from Sequel, and is therefore distributed 
+# under Sequel's LICENCE. 
+#
+# Copyright (c) 2007-2008 Sharon Rosner
+# Copyright (c) 2008-2009 Jeremy Evans
+# 
+# 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 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.
+
+#
+module DbAgile
+  module IO
+    #
+    # Helper to create pretty tables (very much inspired from Sequel's PrettyTable,
+    # see file licence header for details).
+    #
+    module PrettyTable
+    
+      # Prints nice-looking plain-text tables
+      def self.print(records, columns, buffer = "", options = {}) # records is an array of hashes
+        # investigate arguments
+        sizes = column_sizes(records, columns)
+        sep_line = normalize_line(separator_line(columns, sizes), options)
+
+        # start generation now
+        buffer << sep_line << "\n"
+        buffer << normalize_line(header_line(columns, sizes),options) << "\n"
+        buffer << sep_line << "\n"
+        records.each {|r| 
+          buffer << normalize_line(data_line(columns, sizes, r),options) << "\n"
+        }
+        buffer << sep_line << "\n"
+        buffer
+      end
+
+      ### Private Module Methods ###
+      
+      # Normalize the line according to options
+      def self.normalize_line(line, options)
+        if options[:truncate_at] and line.length > options[:truncate_at]
+          ellipse = options[:append_with] || '...'
+          line = line[0..(options[:truncate_at]-ellipse.length)] 
+          line += ellipse
+        end
+        line = line_wrap(line, options[:wrap_at]) if options[:wrap_at]
+        line
+      end
+
+      #
+      # Wraps a line at a given width
+      #
+      # Taken from Ruby Facets
+      # Copyright (c) 2004-2006 Thomas Sawyer
+      # Distributed under the terms of the Ruby license.
+      #
+      def self.line_wrap(line, width, tabs=2)
+        s = line.gsub(/\t/,' ' * tabs) # tabs default to 2 spaces
+        s = s.gsub(/\n/,' ')
+        r = s.scan( /.{1,#{width}}/ )
+        r.join("\n") << "\n"
+      end
+  
+      # Hash of the maximum size of the value for each column 
+      def self.column_sizes(records, columns) # :nodoc:
+        sizes = Hash.new {0}
+        columns.each do |c|
+          s = c.to_s.size
+          sizes[c.to_sym] = s if s > sizes[c.to_sym]
+        end
+        records.each do |r|
+          columns.each do |c|
+            s = r[c].to_s.size
+            sizes[c.to_sym] = s if s > sizes[c.to_sym]
+          end
+        end
+        sizes.each_key{|k| sizes[k] += 1}
+        sizes
+      end
+    
+      # String for each data line
+      def self.data_line(columns, sizes, record) # :nodoc:
+        '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+      end
+    
+      # Format the value so it takes up exactly size characters
+      def self.format_cell(size, v) # :nodoc:
+        case v
+          when NilClass
+            "%-#{size}s" % "[null]"
+          when Bignum, Fixnum
+            "%#{size}d" % v
+          when Float
+            "%#{size}g" % v
+          else
+            "%-#{size}s" % v.to_s
+        end
+      end
+    
+      # String for header line
+      def self.header_line(columns, sizes) # :nodoc:
+        '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+      end
+
+      # String for separtor line
+      def self.separator_line(columns, sizes) # :nodoc:
+        '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+      end
+
+      private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+      private_class_method :line_wrap, :normalize_line
+    end # module PrettyTable
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/ruby.rb

@@ -0,0 +1,62 @@
+module DbAgile
+  module IO
+    module Ruby
+      
+      class Reader
+        
+        def initialize(io, options)
+          @io = io
+          @options = options
+        end
+
+        # Reads content of a file        
+        def read(file)
+          if @options[:input_file]
+            file = File.join(File.dirname(@options[:input_file]), file)
+          end
+          File.read(file)
+        end
+        
+        def tuples
+          self.instance_eval(@io.read)
+        end
+        
+      end
+      
+      # 
+      # Outputs some data as a Ruby string
+      #
+      # @return [...] the buffer itself
+      #
+      def to_ruby(data, columns = nil, buffer = "", options = {})
+        require 'sbyc/type_system/ruby'
+        buffer << "["
+        first = true
+        data.each{|t| 
+          buffer << (first ? "\n  " : ",\n  ")
+          buffer << SByC::TypeSystem::Ruby::to_literal(t)
+          first = false
+        }
+        buffer << "\n]"
+      end
+      module_function :to_ruby
+      
+      #
+      # Interprets io as ruby code that returns an array of tuples 
+      # (Hash instance). If a block if given, yields it with each tuple in 
+      # turn. Otherwise returns it.
+      #
+      def from_ruby(io, options = {}, &block)
+        tuples = Reader.new(io, options).tuples
+        if block
+          tuples.each(&block)
+          nil
+        else
+          tuples
+        end
+      end
+      module_function :from_ruby
+      
+    end # module Ruby
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/text.rb

@@ -0,0 +1,18 @@
+module DbAgile
+  module IO
+    module Text
+      
+      # 
+      # Outputs some data as a plain text string
+      #
+      # @return [...] the buffer itself
+      #
+      def to_text(data, columns, buffer = "", options = {})
+        ::DbAgile::IO::PrettyTable::print(data, columns, buffer, options)
+        buffer
+      end
+      module_function :to_text
+      
+    end # module Text
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/type_safe.rb

@@ -0,0 +1,65 @@
+module DbAgile
+  module IO
+    module TypeSafe
+      
+      # Encodes a tuple to a type safe tuple
+      def to_typesafe_tuple(type_system, tuple)
+        return tuple if type_system.nil?
+        copy = {}
+        tuple.each_pair{|k,v| copy[k] = type_system.to_literal(v)}
+        copy
+      end
+      
+      # Yields the block with each tuple in turn
+      def with_type_safe_relation(data, options, &block)
+        if ts = options[:type_system]
+          data.each{|t| block.call(to_typesafe_tuple(ts, t))}
+        else
+          data.each(&block)
+        end
+      end
+      
+      # Encodes a tuple to a type safe tuple
+      def to_typesafe_relation(type_system, relation)
+        return relation if type_system.nil?
+        relation.collect{|t| to_typesafe_tuple(type_system, t)}
+      end
+      
+      # Decodes a type-safe tuple to a tuple
+      def from_typesafe_tuple(type_system, tuple)
+        return tuple if type_system.nil?
+        copy = {}
+        tuple.each_pair{|k,v| 
+          k = k.to_sym unless k.kind_of?(Symbol)
+          copy[k] = type_system.parse_literal(v)
+        }
+        copy
+      end
+      
+      # Decodes an type-safe encoded relation
+      def from_typesafe_relation(type_system, relation)
+        return relation if type_system.nil?
+        relation.collect{|t| from_typesafe_tuple(type_system, t)}
+      end
+      
+      # Implements the from_xxx emitter spec
+      def from_typesafe_xxx(data, options, &block)
+        if block.nil?
+          from_typesafe_relation(options[:type_system], data)
+        else
+          if data.respond_to?(:each)
+            ts = options[:type_system]
+            data.each do |d|
+              raise DbAgile::InvalidFormatError, "Loaded tuple should be an hash (#{d.inspect})" unless d.kind_of?(Hash)
+              yield(from_typesafe_tuple(ts, d))
+            end
+          else 
+            raise DbAgile::InvalidFormatError, "Loaded data should be an array of tuples (#{data.inspect})"
+          end
+          nil
+        end
+      end
+      
+    end # module TypeSafe
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/xml.rb

@@ -0,0 +1,35 @@
+module DbAgile
+  module IO
+    module XML
+      
+      DEFAULT_OPTIONS = { :table_element_name  => "table",
+                          :row_element_name    => "record"}
+      
+      # 
+      # Outputs some data as a XML string
+      #
+      # @return [...] the buffer itself
+      #
+      def to_xml(data, columns = nil, buffer = "", options = {})
+        require 'builder'
+        options = DEFAULT_OPTIONS.merge(options)
+        ten, ren, cen = options[:table_element_name], 
+                        options[:row_element_name],
+                        options[:column_element_name]
+        buffer << '<?xml version="1.0" encoding="UTF-8"?>' << "\n"
+        buffer << "<#{ten}>"<< "\n"
+        data.each{|row|
+          buffer << "  " << "<#{ren}>" << "\n"
+          columns.each{|column|
+            buffer << "    " << "<#{column}>#{row[column].to_s.to_xs}</#{column}>" << "\n"
+          }
+          buffer << "  " << "</#{ren}>" << "\n"
+        }
+        buffer << "</#{ten}>"<< "\n"
+        buffer
+      end
+      module_function :to_xml
+      
+    end # module YAML
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io/yaml.rb

@@ -0,0 +1,30 @@
+module DbAgile
+  module IO
+    module YAML
+      extend IO::TypeSafe
+      
+      # 
+      # Outputs some data as a YAML string
+      #
+      # @return [...] the buffer itself
+      #
+      def to_yaml(data, columns = nil, buffer = "", options = {})
+        require 'yaml'
+        ::YAML::dump(to_typesafe_relation(options[:type_system], data), buffer)
+        buffer
+      end
+      module_function :to_yaml
+      
+      #
+      # Loads some data from a yaml input. If a block is given, yields it with
+      # each tuple in turn and returns nil. Otherwise returns an array of tuples.
+      #
+      def from_yaml(input, options = {}, &block)
+        require 'yaml'
+        from_typesafe_xxx(::YAML::load(input), options, &block)
+      end
+      module_function :from_yaml
+      
+    end # module YAML
+  end # module IO
+end # module DbAgile

data/lib/dbagile/io.rb

@@ -0,0 +1,94 @@
+require 'dbagile/io/type_safe'
+require 'dbagile/io/pretty_table'
+require 'dbagile/io/csv'
+require 'dbagile/io/json'
+require 'dbagile/io/yaml'
+require 'dbagile/io/xml'
+require 'dbagile/io/ruby'
+require 'dbagile/io/text'
+module DbAgile
+  module IO
+    
+    # Options to set to ensure roundtrip on each format
+    ROUND_TRIP_OPTIONS = {
+      :type_system => SByC::TypeSystem::Ruby
+    }
+      
+    # Known IO formats
+    KNOWN_FORMATS = [:yaml, :csv, :json, :ruby, :text, :xml]
+    
+    # Known to_xxx IO formats
+    KNOWN_TO_FORMATS = [:yaml, :csv, :json, :ruby, :text, :xml]
+    
+    # Known from_xxx formats
+    KNOWN_FROM_FORMATS = [:yaml, :csv, :json, :ruby]
+    
+    # Format to helper module
+    FORMAT_TO_MODULE = {
+      :yaml => DbAgile::IO::YAML,
+      :csv  => DbAgile::IO::CSV,
+      :json => DbAgile::IO::JSON,
+      :ruby => DbAgile::IO::Ruby,
+      :text => DbAgile::IO::Text,
+      :xml  => DbAgile::IO::XML
+    }
+    
+    # Which format for what extension
+    EXTENSION_TO_FORMAT = {
+      ".csv"   => :csv,
+      ".txt"   => :text,
+      ".json"  => :json,
+      ".yaml"  => :yaml,
+      ".yml"   => :yaml,
+      ".xml"   => :xml,
+      ".ruby"  => :ruby,
+      ".rb"    => :ruby
+    }
+    
+    # Which content type for which format
+    FORMAT_TO_CONTENT_TYPE = {
+      :csv  => "text/csv",
+      :text => "text/plain",
+      :json => "application/json",
+      :yaml => "text/yaml",
+      :xml  => "text/xml",
+      :ruby => "text/plain"
+    }
+      
+    # Checks if an extension is known. Returns the associated format.
+    def known_extension?(f)
+      f = ".#{f}" unless f[0,1] == '.'
+      EXTENSION_TO_FORMAT[f]
+    end
+    
+    # Checks if a format is known. Returns the associated content type.
+    def known_format?(f)
+      FORMAT_TO_CONTENT_TYPE[f]
+    end
+    
+    # Returns roundtrip options
+    def roundtrip_options(format)
+      ROUND_TRIP_OPTIONS
+    end
+    
+    # Install helper methods now
+    KNOWN_TO_FORMATS.each{|format|
+      module_eval <<-EOF
+        def to_#{format}(*args, &block)
+          FORMAT_TO_MODULE[#{format.inspect}].to_#{format}(*args, &block)
+        end
+      EOF
+    }
+    
+    # Install helper methods now
+    KNOWN_FROM_FORMATS.each{|format|
+      module_eval <<-EOF
+        def from_#{format}(*args, &block)
+          FORMAT_TO_MODULE[#{format.inspect}].from_#{format}(*args, &block)
+        end
+      EOF
+    }
+    
+    extend(DbAgile::IO)
+  end # module IO
+end # module DbAgile

data/lib/dbagile/loader.rb

@@ -0,0 +1,16 @@
+require 'dbagile/robustness'
+
+# standard library
+DbAgile::Robustness::has_stdlib! 'time'
+DbAgile::Robustness::has_stdlib! 'fileutils'
+DbAgile::Robustness::has_stdlib! 'pathname'
+DbAgile::Robustness::has_stdlib! 'tempfile'
+DbAgile::Robustness::has_stdlib! 'date'
+DbAgile::Robustness::has_stdlib! 'yaml'
+DbAgile::Robustness::has_stdlib! 'readline'
+DbAgile::Robustness::has_stdlib! 'stringio'
+
+# external gems
+DbAgile::Robustness::has_gem! "sbyc", ">= 0.1.4"
+DbAgile::Robustness::has_gem! "sequel", ">= 3.8.0"
+DbAgile::Robustness::has_gem! 'highline', '>= 1.5.2'

data/lib/dbagile/plugin.rb

@@ -0,0 +1,29 @@
+module DbAgile
+  # 
+  # Defines common contract of all plugins inside the adapter chain
+  #
+  class Plugin
+    include DbAgile::Contract::Utils::Delegate
+    include DbAgile::Tools::Tuple
+    
+    # Plugin options
+    attr_reader :options
+    
+    # Returns an instance
+    def self.[](*args)
+      self.new(*args)
+    end
+    
+    # Creates a brick instance with a given delegate
+    def initialize(options = {})
+      @options = default_options.merge(options)
+    end
+    
+    # Returns default brick options
+    def default_options
+      {}
+    end
+    
+    private :default_options
+  end # class Plugin
+end # module DbAgile

data/lib/dbagile/restful/client/delete.rb

@@ -0,0 +1,22 @@
+module DbAgile
+  module Restful
+    class Client
+      module Delete
+
+        # Makes a delete request
+        def delete(path, projection = nil)
+          with_uri(path, projection) do |uri|
+            Net::HTTP.start(uri.host, uri.port) {|http|
+              req = Net::HTTP::Delete.new(uri.path)
+              req.set_form_data(projection) unless projection.nil?
+              res = http.request(req)
+              yield(res, http)
+              res.body
+            }
+          end
+        end
+  
+      end # module Delete
+    end # class Client
+  end # module Restful
+end # module DbAgile

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

@@ -0,0 +1,24 @@
+module DbAgile
+  module Restful
+    class Client
+      module Get
+
+        # Makes a get request
+        def get(path, projection = nil)
+          with_uri(path, projection) do |uri|
+            Net::HTTP.start(uri.host, uri.port) {|http|
+              res = if uri.query
+                http.get(uri.path + "?" + uri.query)
+              else
+                http.get(uri.path)
+              end
+              yield(res, http)
+              res.body
+            }
+          end
+        end
+        
+      end # module Get
+    end # class Client
+  end # module Restful
+end # module DbAgile

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

@@ -0,0 +1,22 @@
+module DbAgile
+  module Restful
+    class Client
+      module Post
+
+        # Makes a post request
+        def post(path, tuple)
+          with_uri(path) do |uri|
+            Net::HTTP.start(uri.host, uri.port) {|http|
+              req = Net::HTTP::Post.new(uri.path)
+              req.set_form_data(tuple)
+              res = http.request(req)
+              yield(res, http)
+              res.body
+            }
+          end
+        end
+  
+      end # module Post
+    end # class Client
+  end # module Restful
+end # module DbAgile

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

@@ -0,0 +1,16 @@
+module DbAgile
+  module Restful
+    class Client
+      module Utils
+
+        # Yields the block with an URI to access the server
+        def with_uri(path, projection = nil)
+          uri = "#{server_uri}#{path}"
+          uri += ("?" + tuple_to_querystring(projection)) if projection
+          yield(URI.parse(uri))
+        end
+        
+      end # module Get
+    end # module Utils
+  end # module Restful
+end # module DbAgile

data/lib/dbagile/restful/client.rb

@@ -0,0 +1,41 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'dbagile/restful/client/utils'
+require 'dbagile/restful/client/get'
+require 'dbagile/restful/client/post'
+require 'dbagile/restful/client/delete'
+module DbAgile
+  module Restful
+    #
+    # Helper to query the restful server
+    #
+    class Client
+      include DbAgile::Restful::Client::Utils
+      include DbAgile::Restful::Client::Get
+      include DbAgile::Restful::Client::Post
+      include DbAgile::Restful::Client::Delete
+      include DbAgile::Tools::Tuple
+
+      # Server uri
+      attr_reader :server_uri
+      
+      #
+      # Creates a client instance.
+      #
+      # @param [String|URI] the uri of the restful server
+      #
+      def initialize(server_uri)
+        @server_uri = case server_uri
+          when URI
+            server_uri
+          when String
+            URI.parse(server_uri)
+          else
+            raise ArgumentError, "Invalid server uri: #{server_uri}"
+        end
+      end
+      
+    end # class Client
+  end # module Restful
+end # module DbAgile

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

@@ -0,0 +1,22 @@
+module DbAgile
+  module Restful
+    class Middleware
+      module Delete
+      
+        # Implements DELETE access of the restful interface
+        def delete(env)
+          request = Rack::Request.new(env)
+          decode(env) do |connection, table, format|
+            heading = connection.heading(table)
+            tuple = params_to_tuple(request.POST, heading)
+            connection.transaction do |t|
+              t.delete(table, tuple)
+            end
+            [ :json, [ JSON::generate(:ok => true) ] ]
+          end
+        end
+      
+      end # module Delete
+    end # class Middleware
+  end # module Restful
+end # module Facts