irjudson-dm-persevere-adapter 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 / 2009-02-19
+
+* Release!
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Montana State University
+
+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 OR COPYRIGHT HOLDERS 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.

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+LICENSE.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO
+lib/persevere_adapter.rb
+lib/persevere_adapter/version.rb
+spec/integration/persevere_adapter_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/install.rb
+tasks/spec.rb

data/README.txt

@@ -0,0 +1,86 @@
+= dm-persevere-adapter
+
+A DataMapper adapter for Persevere (http://www.persvr.org/)
+
+This requires the persevere gem (http://github.com/irjudson/persevere) which provides a ruby interface to Persevere.
+
+== Usage
+
+DM Persevere Adapter is very simple and very similar to the REST
+Adapter, however it has two differences: 1) instead of XML it uses
+JSON, and 2) Persevere supports typing using JSON Schema. These
+differences make it valuable to have a separate DM adapter
+specifically for Persevere so it can leverage richer aspects of
+persevere.
+
+The setup and resource mapping is identical to standard datamapper
+objects, as can be seen below.
+
+DataMapper.setup(:default, {
+                   :adapter => 'persevere',
+                   :host => 'localhost',
+                   :port => '8080'
+                 })
+
+class MyUser
+  include DataMapper::Resource
+
+  property :id,            Serial
+  property :uuid,          String
+  property :name,          String
+  property :first_name,    String
+  property :last_name,     String
+  property :groupid,       Integer
+  property :userid,        Integer
+  property :username,      String
+  property :homedirectory, String
+
+end
+
+To use with Rails, you can put this in your environment.rb:
+  config.gem "dm-core"
+  config.gem "data_objects"
+  config.gem "dm-persevere-adapter", :lib => 'persevere_adapter'
+
+With a database.yml:
+
+development: &defaults
+  :adapter: persevere
+  :host: localhost
+  :port: 8080
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults
+
+== Code
+
+# Create
+user = MyUser.new(:username => "dmtest", :uuid => UUID.random_create().to_s,
+                  :name => "DataMapper Test", :homedirectory => "/home/dmtest",
+                  :first_name => "DataMapperTest", :last_name => "User",
+                  :userid => 3, :groupid => 500)
+user.save
+
+# Retrieve
+user = MyUser.first(:netid => 'dmtest')
+puts user
+
+# Modify
+if user.update_attributes(:name => 'DM Test')
+  puts user
+else
+  puts "Failed to update attributes."
+end
+
+# Delete
+result = user.destroy
+puts "Result: #{result}"
+
+== To Do:
+
+- Make a do-adapter for persevere.
+- Finish Query details (limit, order, etc)
+- Cleanup Documentation

data/Rakefile

@@ -0,0 +1,37 @@
+require 'pathname'
+require 'rubygems'
+require 'hoe'
+
+ROOT    = Pathname(__FILE__).dirname.expand_path
+JRUBY   = RUBY_PLATFORM =~ /java/
+WINDOWS = Gem.win_platform?
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+require ROOT + 'lib/persevere_adapter/version'
+
+# define some constants to help with task files
+GEM_NAME    = 'dm-persevere-adapter'
+GEM_VERSION = DataMapper::PersevereAdapter::VERSION
+
+Hoe.new(GEM_NAME, GEM_VERSION) do |p|
+  p.developer('Ivan R. Judson', 'irjudson [a] gmail [d] com')
+
+  p.description = 'A DataMapper Adapter for persevere'
+  p.summary = 'A DataMapper Adapter for persevere'
+  p.url = 'http://github.com/USERNAME/dm-persevere-adapter'
+
+  p.clean_globs |= %w[ log pkg coverage ]
+  p.spec_extras = { 
+    :has_rdoc => true, 
+    :extra_rdoc_files => %w[ README.txt LICENSE.txt TODO History.txt ]
+  }
+
+  p.extra_deps = [
+    ['dm-core', "~> 0.9.10"], 
+    ['extlib', "~> 0.9.10"], 
+    ['persevere', "~> 1.0.0"]
+  ]
+
+end
+
+Pathname.glob(ROOT.join('tasks/**/*.rb').to_s).each { |f| require f }

data/lib/persevere_adapter.rb

@@ -0,0 +1,310 @@
+gem 'dm-core', '~> 0.9.10'
+require 'dm-core'
+require 'rubygems'
+require 'extlib'
+require 'json'
+require 'persevere'
+
+module DataMapper
+  module Adapters
+    class PersevereAdapter < AbstractAdapter
+      ##
+      # Used by DataMapper to put records into a data-store: "INSERT"
+      # in SQL-speak.  It takes an array of the resources (model
+      # instances) to be saved. Resources each have a key that can be
+      # used to quickly look them up later without searching, if the
+      # adapter supports it.
+      #
+      # @param [Array<DataMapper::Resource>] resources
+      #   The set of resources (model instances)
+      #
+      # @return [Integer]
+      #   The number of records that were actually saved into the
+      #   data-store
+      #
+      # @api semipublic
+      def create(resources)
+        created = 0
+        resources.each do |resource|
+          #
+          # This isn't the best solution but for an adapter, it'd be nice
+          # to support objects being in *tables* instead of in one big icky
+          # sort of table.
+          #
+          tblname = Extlib::Inflection.classify(resource.class).pluralize
+
+          if ! @classes.include?(tblname)
+            payload = {
+              'id' => tblname,
+              'extends' => { "$ref" => "/Class/Object" }
+            }
+
+            response = @persevere.create("/Class/", payload)
+          end
+
+          path = "/#{tblname}/"
+          payload = resource.attributes
+          payload.delete(:id)
+
+          response = @persevere.create(path, payload)
+
+          # Check the response, this needs to be more robust and raise
+          # exceptions when there's a problem
+
+          if response.code == "201"# good:
+            rh = JSON.parse(response.body)
+            created += 1
+          else
+            return false
+          end
+        end
+
+        # Return the number of resources created in persevere.
+        return created
+      end
+
+      ##
+      # Used by DataMapper to update the attributes on existing
+      # records in a data-store: "UPDATE" in SQL-speak. It takes a
+      # hash of the attributes to update with, as well as a query
+      # object that specifies which resources should be updated.
+      #
+      # @param [Hash] attributes
+      #   A set of key-value pairs of the attributes to update the
+      #   resources with.
+      # @param [DataMapper::Query] query
+      #   The query that should be used to find the resource(s) to
+      #   update.
+      #
+      # @return [Integer]
+      #   the number of records that were successfully updated
+      #
+      # @api semipublic
+      def update(attributes, query)
+        updated = 0
+        puts "In Update A: #{attributes} Q: #{query.conditions.inspect}"
+        resources = read_many(query)
+        puts "Resources found: #{resources}"
+        resources.each do |resource|
+          key = resource.class.key(self.name).map do |property|
+            resource.instance_variable_get(property.instance_variable_name)
+          end
+
+          tblname = Extlib::Inflection.classify(resource.class).pluralize
+          path = "/#{tblname}/#{resource.id}"
+
+          result = @persevere.update(path, resource.attributes)
+
+          if result # good:
+            updated += 1
+          else
+            return false
+          end
+        end
+        return updated
+      end
+
+      ##
+      # Look up a single record from the data-store. "SELECT ... LIMIT
+      # 1" in SQL.  Used by Model#get to find a record by its
+      # identifier(s), and Model#first to find a single record by some
+      # search query.
+      #
+      # @param [DataMapper::Query] query
+      #   The query to be used to locate the resource.
+      #
+      # @return [DataMapper::Resource]
+      #   A Resource object representing the record that was found, or
+      #   nil for no matching records.
+      #
+      # @api semipublic
+
+      def read_one(query)
+        read_many(query)[0]
+      end
+
+      ##
+      # Looks up a collection of records from the data-store: "SELECT"
+      # in SQL.  Used by Model#all to search for a set of records;
+      # that set is in a DataMapper::Collection object.
+      #
+      # @param [DataMapper::Query] query
+      #   The query to be used to seach for the resources
+      #
+      # @return [DataMapper::Collection]
+      #   A collection of all the resources found by the query.
+      #
+      # @api semipublic
+      def read_many(query)
+        resources = Array.new
+
+        json_query = make_json_query(query.conditions)
+
+        tblname = Extlib::Inflection.classify(query.model).pluralize
+        path = "/#{tblname}/#{json_query}"
+
+        response = @persevere.retrieve(path)
+
+        if response.code == "200"
+          results = JSON.parse(response.body)
+          results.each do |result|
+            values = query.fields.collect do |field|
+              result[field.field.to_s]
+            end
+            resources << query.model.load(values, query)
+          end
+        else
+          return false
+        end
+
+        # Return results
+        resources
+      end
+
+      alias :read :read_many
+
+      ##
+      # Destroys all the records matching the given query. "DELETE" in SQL.
+      #
+      # @param [DataMapper::Query] query
+      #   The query used to locate the resources to be deleted.
+      #
+      # @return [Integer]
+      #   The number of records that were deleted.
+      #
+      # @api semipublic
+      def delete(query)
+        deleted = 0
+        resources = read_many(query)
+        resources.each do |resource|
+          key = resource.class.key(self.name).map do |property|
+            resource.instance_variable_get(property.instance_variable_name)
+          end
+
+          tblname = Extlib::Inflection.classify(resource.class).pluralize
+          path = "/#{tblname}/#{resource.id}"
+
+          result = @persevere.delete(path)
+
+          if result # ok
+            deleted += 1
+          end
+        end
+        return deleted
+      end
+
+      private
+
+      ##
+      # Make a new instance of the adapter. The @model_records ivar is
+      # the 'data-store' for this adapter. It is not shared amongst
+      # multiple incarnations of this adapter, eg
+      # DataMapper.setup(:default, :adapter => :in_memory);
+      # DataMapper.setup(:alternate, :adapter => :in_memory) do not
+      # share the data-store between them.
+      #
+      # @param [String, Symbol] name
+      #   The name of the DataMapper::Repository using this adapter.
+      # @param [String, Hash] uri_or_options
+      #   The connection uri string, or a hash of options to set up
+      #   the adapter
+      #
+      # @api semipublic
+
+      def initialize(name, uri_or_options)
+        super
+        @persevere = Persevere.new(make_uri(uri_or_options))
+        @resource_naming_convention = NamingConventions::Resource::Underscored
+        @identity_maps = {}
+        @classes = []
+
+        # Because this is an AbstractAdapter and not a
+        # DataObjectAdapter, we can't assume there are any schemas
+        # present, so we retrieve the ones that exist and keep them up
+        # to date
+        result = @persevere.retrieve('/Class[=id]')
+        if result.code == "200"
+          hresult = JSON.parse(result.body)
+          hresult.each do |cname|
+            junk,name = cname.split("/")
+            @classes << name
+          end
+
+        else
+          puts "Error retrieving existing tables: ", result.message
+        end
+      end
+
+      def make_uri(uri_or_options)
+        if uri_or_options.is_a?(String)
+          begin
+            URI.parse(uri_or_options)
+            return uri_or_options.to_s
+          rescue URI::InvalidURIError => e
+            puts "Error parsing persevere URI: ", e
+          end
+        elsif uri_or_options.is_a?(Hash)
+          nh = uri_or_options.dup
+          nh[:scheme] = nh[:adapter]
+          nh.delete(:scheme)
+          return URI::HTTP.build(nh).to_s
+        end
+      end
+
+      ##
+      # Convert a DataMapper Resource to a JSON.
+      #
+      # @param [Query] query
+      #   The DataMapper query object passed in
+      #
+      # @api semipublic
+      def make_json(resource)
+        json_rsrc = nil
+
+        # Gather up all the attributes
+        json_rsrc = resource.attributes.to_json
+      end
+
+      ##
+      # Convert a DataMapper Query to a JSON Query.
+      #
+      # @param [Query] query
+      #   The DataMapper query object passed in
+      #
+      # @api semipublic
+
+      def make_json_query(conditions)
+        query_terms = Array.new
+        conditions.each do |condition|
+          v = condition[1].typecast(condition[2])
+          if v.is_a?(String)
+            value = "'#{condition[2]}'"
+          else
+            value = "#{condition[2]}"
+          end
+          case condition[0]
+          when :eql
+            query_terms << "#{condition[1].field()}=#{value}"
+          when :lt
+            query_terms << "#{condition[1].field()}<#{value}"
+          when :gt
+            query_terms << "#{condition[1].field()}>#{value}"
+          when :lte
+            query_terms << "#{condition[1].field()}<=#{value}"
+          when :gte
+            query_terms << "#{condition[1].field()}=>#{value}"
+          when :not
+            query_terms << "#{condition[1].field()}!=#{value}"
+          when :like
+            if condition[2].is_a?(String)
+              query_terms << "#{condition[1].field()}~'*#{condition[2].to_s}*'"
+            end
+          else
+            puts "Unknown condition: #{condition[0]}"
+          end
+        end
+        query = "?#{query_terms.join("&")}"
+      end
+    end
+  end
+end

data/lib/persevere_adapter/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module PersevereAdapter
+    VERSION = '0.0.2'
+  end
+end

data/spec/integration/persevere_adapter_spec.rb

@@ -0,0 +1,6 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe 'DataMapper::Adapters::PersevereAdapter' do
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'rspec'
+require 'spec'
+
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/persevere_adapter'
+
+DataMapper.setup(:default, {
+                            :adapter => 'persevere',
+                            :host => 'localhost',
+                            :port => '8080',
+                            :uri => 'http://localhost:8080'
+                           })
+
+#
+# I need to make the Book class for Books to relate to
+#
+
+class Book
+  include DataMapper::Resource
+
+  # Persevere only does id's as strings.  
+  property :id, String, :serial => true
+  property :author, String
+  property :created_at, DateTime
+  property :title, String
+end

data/tasks/install.rb

@@ -0,0 +1,13 @@
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
+
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"
+task :uninstall => [ :clobber ] do
+  sudo_gem "uninstall #{GEM_NAME} -v#{GEM_VERSION} -Ix"
+end

data/tasks/spec.rb

@@ -0,0 +1,25 @@
+begin
+  gem 'rspec'
+  require 'spec'
+  require 'spec/rake/spectask'
+
+  task :default => [ :spec ]
+
+  desc 'Run specifications'
+  Spec::Rake::SpecTask.new(:spec) do |t|
+    t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+    t.spec_files = Pathname.glob((ROOT + 'spec/**/*_spec.rb').to_s)
+
+    begin
+      gem 'rcov', '~>0.8'
+      t.rcov = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
+      t.rcov_opts << '--exclude' << 'spec'
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    rescue LoadError
+      # rcov not installed
+    end
+  end
+rescue LoadError
+  # rspec not installed
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: irjudson-dm-persevere-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Ivan R. Judson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-19 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core~
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.10
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: A DataMapper Adapter for persevere
+email: 
+- irjudson [a] gmail [d] com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+- LICENSE.txt
+- TODO
+- History.txt
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- lib/persevere_adapter.rb
+- lib/persevere_adapter/version.rb
+- spec/integration/persevere_adapter_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/install.rb
+- tasks/spec.rb
+has_rdoc: true
+homepage: http://github.com/USERNAME/dm-persevere-adapter
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dm-persevere-adapter
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A DataMapper Adapter for persevere
+test_files: []
+