rdf-mapper 0.0.1

data/lib/lib/scope/query.rb

@@ -0,0 +1,281 @@
+module RDFMapper
+  module Scope
+    ##
+    # [-]
+    ##
+    class Query
+      
+      include RDFMapper::Logger
+      
+      attr_reader :cls
+      attr_reader :conditions
+      attr_reader :sql # Remaining unparsed conditions
+      
+      def initialize(cls, options = {})
+        @options = options
+        @conditions = []
+        @options[:include] ||= []
+        @cls = cls
+        @modifier = :and
+
+        case @options[:conditions]
+          when Hash   then parse_hash
+          when Array  then parse_array
+        end
+        
+      end
+      
+      ##
+      # [-]
+      ##
+      def modifier
+        @modifier.to_s.upcase
+      end
+      
+      ##
+      # [-]
+      ##
+      def strict?
+        @modifier == :and
+      end
+      
+      ##
+      # [-]
+      ##
+      def offset
+        @options[:offset] || 0
+      end
+      
+      ##
+      # [-]
+      ##
+      def limit
+        @options[:limit]
+      end
+      
+      ##
+      # [-]
+      ##
+      def include
+        @options[:include]
+      end
+      
+      ##
+      # [-]
+      ##
+      def include!(name)
+        @options[:include] << name
+      end
+      
+      ##
+      # @todo. Not implemented
+      ##
+      def order
+        nil
+      end
+      
+      ##
+      # [-]
+      ##
+      def [](name)
+        @conditions.select do |condition|
+          condition.name == name
+        end.map do |condition|
+          condition.value
+        end.first
+      end
+      
+      ##
+      # Follows the same logic as `to_a` method and returns a Hash instead
+      # of an Array (:name => { :eq => value, :value => value }).
+      #
+      # @see to_a
+      #
+      # @param [Array<Symbol>] required association attributes that should be preloaded
+      # @return [Hash]
+      ##
+      def to_hash(required = [])
+        Hash[to_a(required).map do |name, eq, value|
+          [name, { :eq => eq, :value => value }]
+        end]
+      end
+      
+      ##
+      # Returns an Array of search conditions. Will preload any associated
+      # models if their properties are undefined (e.g. in case of REST and
+      # SPARQL models are required to have `id` as RDF::URI, and `rails_id`
+      # in case of Rails).
+      #
+      # Note that any foreign-key associations will be renamed. For instance:
+      #   :employee_id => #<RDF::URI(http://example.org/people/1354534)>
+      # is transformed into
+      #   :employee => #<RDFMapper::Model:217132856>
+      #
+      # @param [Array<Symbol>] required association attributes that should be preloaded
+      # @return [Array<Condition>]
+      ##
+      def to_a(required = [])
+        unless required.kind_of? Array
+          required = [required]
+        end
+        @conditions.each do |condition|
+          condition.check(required)
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def to_triples
+        to_statements.map do |statement|
+          [ statement[:subject], statement[:predicate], statement[:object] ]
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def to_statements
+        target = if self[:id].nil?
+          RDF::Query::Variable.new
+        else
+          RDF::URI.new(self[:id].to_s)
+        end
+        [{ :subject => target,
+           :predicate => RDF.type,
+           :object => @cls.type
+        }] + to_a(:id).map do |condition|
+          condition.to_statements(target)
+        end.flatten.compact
+      end
+      
+      ##
+      # [-]
+      ##
+      def flatten(required = [])
+        to_a(required).map do |condition|
+          (condition.class == self.class) ? condition.flatten(required) : condition
+        end.flatten
+      end
+      
+      alias_method :check, :to_a
+      
+      ##
+      # Developer-friendly representation of the instance
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        "#<Query%s>" % to_a.map do |condition|
+          condition.inspect
+        end.inspect
+      end
+      
+      
+      private
+
+      def add_condition(name, value, eq = '=') #nodoc
+        if value.kind_of? Array and value.empty?
+          raise RuntimeError, 'No value assigned to `%s`' % name
+        end
+        @conditions << RDFMapper::Scope::Condition.new(@cls, name, value, eq)
+      end
+
+      ##
+      # [-]
+      ##
+      def parse_array #nodoc
+        @ary = @options[:conditions][1,255]
+        while (read_subquery || read_collection || read_value || read_modifier); end
+      end
+      
+      ##
+      # [-]
+      ##
+      def read_collection #nodoc
+        full, name = match(/([^\s]+)[\s]*IN[\s]+\(\?\)[\s]*/)
+        return nil if full.nil?
+        add_condition(name, @ary.shift)
+      end
+
+      ##
+      # [-]
+      ##
+      def read_modifier #nodoc
+        full, modifier = match(/[\s]*(AND|OR)/)
+        return nil if full.nil?
+        @modifier = (modifier == 'OR') ? :or : :and
+      end
+
+      ##
+      # [-]
+      ##
+      def read_value #nodoc
+        full, name, eq, value, literal, digit = match(/([^\s]+)[\s]*([=><]+)\s*("([\s\w]*)"|([\d\.]+))/)
+        return nil if full.nil?
+        value = literal.nil? ? digit.to_f : literal.to_s
+        add_condition(name, value, eq)
+      end
+
+      ##
+      # [-]
+      ##
+      def read_subquery #nodoc
+        read_subquery_start || read_subquery_end
+      end
+
+      ##
+      # [-]
+      ##
+      def read_subquery_start #nodoc
+        return nil if match(/\(/).nil?
+        sub = Query.new(@cls, :conditions => [@sql] + @ary)
+        @sql = sub.sql[1, sub.sql.length]
+        @conditions << sub
+      end
+
+      ##
+      # [-]
+      ##
+      def read_subquery_end #nodoc
+        return nil if match(/\)/).nil?
+        @sql = "|" + @sql
+      end
+      
+      ##
+      # Returns a match array
+      ##
+      def match(pattern)
+        if @sql.nil?
+          @sql = @options[:conditions].first
+        end
+        if (@sql =~ pattern) == 0
+          @sql = $'.lstrip
+          Regexp.last_match.to_a
+        end
+      end
+      
+      ##
+      # Parses all user-specified `options[:conditions]`
+      ##
+      def parse_hash #nodoc
+        @options[:conditions].map do |att, value|
+          parse_hash_item(att, value)
+        end.flatten
+      end
+      
+      ##
+      # Parses a single `option`
+      ##
+      def parse_hash_item(att, value) #nodoc
+        if value.kind_of? Array
+          return value.map do |item|
+            parse_hash_item(att, item)
+          end
+        end
+        add_condition(att, value)
+      end
+      
+    end # Query
+  end # Scope
+end # RDFMapper

data/lib/lib/util/http.rb

@@ -0,0 +1,66 @@
+module RDFMapper
+  ##
+  # Basic HTTP interface, built on top of Patron[http://github.com/toland/patron]
+  # library. Used by RDFMapper adapters for communication with external data sources.
+  #
+  # Patron automatically handles cookies, redirects, timeouts. Can be substituted
+  # by any other library as long as HTTP class implements `get` and `post` methods.
+  ##
+  class HTTP
+
+    require 'patron'
+
+    class << self
+
+      ##
+      # Performs a `GET` request and returns received data
+      #
+      # @param [String, RDF::URI] url
+      # @param [Hash] options for Patron constructor
+      # @return [String]
+      ##
+      def get(url, options = {})
+        self.new(options).get(url.to_s)
+      end
+
+      ##
+      # Performs a `POST` request and returns received data
+      #
+      # @param [String, RDF::URI] url
+      # @param [String] data
+      # @param [Hash] options for Patron constructor
+      # @return [String]
+      ##
+      def post(url, data, options = {})
+        self.new(options).post(url.to_s, data)
+      end
+    
+    end
+
+    ##
+    # @return [self]
+    ##
+    def initialize(options = {})
+      @session = Patron::Session.new
+      @session.handle_cookies
+      @session.timeout = 10
+      @session.headers['User-Agent'] = 'Mozilla / RDFMapper'
+      @options = options
+    end
+    
+    def get(url)
+      @session.get(url, headers).body
+    end
+
+    def post(url, data)
+      @session.post(url, data, headers).body
+    end
+    
+    private
+    
+    def headers
+      @options[:headers] || {}
+    end
+
+  end # HTTP
+end # RDFMapper

data/lib/lib/util/logger.rb

@@ -0,0 +1,68 @@
+module RDFMapper
+  ##
+  # A convenience wrapper around Ruby's standard Logger object.
+  ##
+  module Logger
+    module Configuration
+      class << self
+
+        def to(target, level = 4, name = nil)
+          io = case target
+            when :stdout then $stdout
+            when :file then File.open(name, 'a+')
+            else String
+          end
+          @target = ::Logger.new(io)
+        end
+      
+        def target
+          @target || to(:stdout)
+        end
+        
+      end
+    end
+    
+    ##
+    # Logs a fatal error using RDFMapper::Logger
+    #
+    # @return[true]
+    ##
+    def fatal(message)
+      log(4, message)
+    end
+    
+    ##
+    # Logs a warning message using RDFMapper::Logger
+    #
+    # @return[true]
+    ##
+    def warn(message)
+      log(2, message)
+    end
+    
+    ##
+    # Logs a debug message using RDFMapper::Logger
+    #
+    # @return[true]
+    ##
+    def debug(message)
+      log(0, message)
+    end
+    
+    private
+    
+    ##
+    # Logs a message using RDFMapper::Logger
+    #
+    # @param [Integer] severity from 0 to 5 (see Logger::Severity)
+    # @param [String] message
+    # @return[true] 
+    ##
+    def log(severity, message)
+      timestamp = Time.now.strftime('%m-%d %H:%M:%S')
+      formatted = "[%s] %s | %s" % [timestamp, self.class.name, message]
+      RDFMapper::Logger::Configuration.target.add(severity, formatted)
+    end
+    
+  end
+end

data/lib/rdf-mapper.rb

@@ -0,0 +1,15 @@
+module RDFMapper
+  
+  require 'rdf-xml'
+  require 'rdf-sparql'
+
+  autoload :Model,        'lib/model/base'
+  autoload :Scope,        'lib/scope/model'
+  autoload :Associations, 'lib/associations/base'
+  autoload :Adapters,     'lib/adapters/base'
+  autoload :HTTP,         'lib/util/http'
+  autoload :Logger,       'lib/util/logger'
+  
+end
+
+

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-mapper
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Serebryakov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-27 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rdf-xml
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: patron
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 6
+        version: 0.4.6
+  type: :runtime
+  version_requirements: *id004
+description: RDFMapper is a lightweight Ruby ORM that works with RDF data in a Rails-like fashion. Is supports XML, N-Triples, JSON formats, SPARQL and ActiveRecord as data sources.
+email: serebryakov@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- UNLICENSE
+- VERSION
+- lib/lib/adapters/base.rb
+- lib/lib/adapters/rails.rb
+- lib/lib/adapters/rest.rb
+- lib/lib/adapters/sparql.rb
+- lib/lib/associations/base.rb
+- lib/lib/associations/belongs_to.rb
+- lib/lib/associations/has_and_belongs.rb
+- lib/lib/associations/has_many.rb
+- lib/lib/associations/has_one.rb
+- lib/lib/model/association.rb
+- lib/lib/model/attribute.rb
+- lib/lib/model/base.rb
+- lib/lib/model/output.rb
+- lib/lib/model/property.rb
+- lib/lib/scope/collection.rb
+- lib/lib/scope/condition.rb
+- lib/lib/scope/loader.rb
+- lib/lib/scope/model.rb
+- lib/lib/scope/query.rb
+- lib/lib/util/http.rb
+- lib/lib/util/logger.rb
+- lib/rdf-mapper.rb
+has_rdoc: true
+homepage: http://github.com/42cities/rdf-mapper/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rdf-mapper
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby ORM that is designed to play nicely with RDF data.
+test_files: []
+