atomics_resource 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+## production gems
+gem "nokogiri"
+
+## dev gems
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    nokogiri (1.5.0)
+    rake (0.9.2)
+    rcov (0.9.10)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  nokogiri
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Richard Lister
+
+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/README.rdoc

@@ -0,0 +1,92 @@
+= Atomics Resource
+
+Ruby and/or Rails interface for Atomics queries. Atomics is MySQL over
+HTTP, originally developed at CNET and has similar intent to DBSlayer.
+
+== Philosophy
+
+This module use a different approach from
+e.g. activerecord-dbslayer-adapter, which subclasses the MySQL adapter
+in order to use ActiveRecord. Rather, AtomicsResource is a lightweight
+re-implementation of some ActiveRecord-style methods, which means the
+module can be used in non-Rails apps, or mixed with non-MySQL
+connections in a Rails app.
+
+== Overview
+
+Classes representing resources in atomics are created by subclassing
+AtomicsResource::Base. Class find methods are mapped to HTTP GET
+requests. XML responses are parsed and mapped to an instance of the
+class.
+
+=== Configuration
+
+To use an instance, you will need to create a yaml file with atomics
+configs, e.g. config/atomics.yml:
+
+    hr:
+      host: hr-atomics.newco.com
+      port: 8080
+      path: /jAtomics/select/?version=1
+
+then load the file into a hash called ATOMICS_CONFIG; in Rails this is
+best done from an initializer, e.g. config/initializers/atomics_config.rb:
+
+    ATOMICS_CONFIG = YAML.load_file("#{RAILS_ROOT}/config/atomics.yml")
+
+=== Usage
+
+Your model will look like this:
+
+    class Employee < AtomicsResource::Base
+      set_atomics_type :hr                #section of config file to read
+      set_table_name   :employee_display  #default table for requests
+      set_primary_key  :id                #default key for find() methods
+
+      ## default columns to SELECT, if none-given default will be '*'
+      column :first_name
+      column :last_name
+      column :title
+      column :team_id
+    end
+
+and a simple controller:
+
+    class EmployeesController < ApplicationController
+      def index
+        @employees = Employee.all(:conditions => [ "team_id = ?", params[:team] ]
+                                  :order      => [ :last_name, :first_name ])
+      end
+
+      def show
+        @employee = Employee.find(params[:id])
+      end
+    end
+
+Conditions may be given as follows:
+
+    :conditions => "team_id = 156 AND title = 'Manager'"
+    :conditions => [ "team_id = ? AND title = ?", 156, 'Manager' ]
+    :conditions => [ "team_id = %d AND title = %s", 156 , 'Manager' ]
+    :conditions => { :team_id => 156, :title => :Manager }
+
+Columns: in general you don't want to do "SELECT *" from Atomics
+tables, which are frequently huge, denormalized beasts which will put
+a lot of extra data on the wire that you don't want. Instead, list in
+the model the columns you normally want, using 'column'. These will be
+used to create the default 'SELECT' statement in find(). This can be
+overridden using something like find(:all, :select=>'*').
+
+Convenience functions:
+
+    Employee.all(99)     ## equivalent to Employee.find(:all,   :conditions => {:id = 99})
+    Employee.first(99)   ## equivalent to Employee.find(:first, :conditions => {:id = 99})
+    Employee.last(99)    ## equivalent to Employee.find(:last,  :conditions => {:id = 99})
+
+== Contributing to atomics_resource
+
+The project is available for forking at github.
+
+== Copyright
+
+Copyright (c) 2011 Richard Lister. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "atomics_resource"
+  gem.homepage = "http://github.com/rlister/atomics_resource"
+  gem.license = "MIT"
+  gem.summary = %Q{Active Model for Atomics MySQL lookups}
+  gem.description = %Q{Model Atomics (MySQL over HTTP) records for ruby and rails projects}
+  gem.email = "rlister@github"
+  gem.authors = ["Richard Lister"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "atomics_resource #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/examples/employees.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+## this does not run, but will show you how to configure against your local Atomics instance
+
+require 'rubygems'
+require 'atomics_resource'
+
+ATOMICS_CONFIG = {
+  'hr' => {
+    'host' => 'hr-atomics.newco.com',
+    'port' => '8080',
+    'path' => '/jAtomics/select/?version=1',
+  },
+  'other' => {
+    'host' => 'other-atomics.for.illustration.com',
+    'port' => '80',
+    'path' => '/atomics/raw',
+  },
+}
+
+class Employee < AtomicsResource::Base
+  set_atomics_type :hr
+  set_table_name   :employee_display
+  set_primary_key  :id
+
+  column :first_name
+  column :last_name
+  column :title
+  column :team_id
+end
+
+employees = Employee.all(:conditions => {:team_id => 1},
+                         :order      => [:last_name, :first_name])
+
+employees.each do |e|
+  puts "#{e.last_name},#{e.first_name}: #{e.title}"
+end

data/lib/atomics_resource.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2011 Richard Lister
+#
+# 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.
+#++
+
+## ActiveModel-style interface for Atomics queries.
+
+require 'atomics_resource/base.rb'
+
+module AtomicsResource
+  ## noop
+end

data/lib/atomics_resource/base.rb

@@ -0,0 +1,246 @@
+require 'nokogiri'
+require 'open-uri'
+require 'net/http'
+
+module AtomicsResource
+
+  class Base
+
+    ## class instance variables
+    class << self
+      attr_accessor :atomics_type, :table_name, :primary_key
+      alias_method :set_atomics_type, :atomics_type=
+      alias_method :set_table_name,   :table_name=
+      alias_method :set_primary_key,  :primary_key=
+    end
+
+    ## Get method for array of columns (attr_accessor will break for arrays on inheritance).
+    def self.columns
+      @columns ||= []
+    end
+
+    ## Add a column.
+    def self.column(value)
+      columns << value
+    end
+
+    ## Quote value for Atomics in SQL statment; numeric arguments returned unquoted,
+    ## strings in single quotes.
+    def self.quote_value(value)
+      value.match(/^\d+$/) ? value : "'#{value}'"
+    end
+
+    ## Build a SQL query string from hash of options passed to find.
+    def self.construct_sql(options)
+      sql = []
+      sql << "SELECT "   + construct_sql_for_params(options[:select])
+      sql << "FROM "     + construct_sql_for_params(options[:from])
+      sql << "WHERE "    + construct_sql_for_conditions(options[:conditions]) if options[:conditions]
+      sql << "ORDER BY " + construct_sql_for_params(options[:order]) if options[:order]
+      sql << "LIMIT "    + options[:limit].to_s  if options[:limit]
+      sql << "OFFSET "   + options[:offset].to_s if options[:offset]
+      sql.join(' ')
+    end
+
+    ## Return string for SQL conditions from values params as string, array, or hash.
+    def self.construct_sql_for_params(parms)
+      case parms
+      when Array; parms.map(&:to_s).join(',')
+      when Hash;  parms.keys.map(&:to_s).join(',')
+      else parms.to_s
+      end
+    end
+
+    ## Return string for SQL conditions from options params as string, array, or hash.
+    def self.construct_sql_for_conditions(option)
+      case option
+      when Array; construct_sql_for_array(option)
+      when Hash;  construct_sql_for_hash (option) ## :TODO: implement this
+      else option
+      end
+    end
+
+    ## Construct string of conditions from an array of format plus values to substitute.
+    ## Examples:
+    ##   [ 'foo = ? AND bar = ?', 'hello', 99 ]
+    ##   [ 'foo = %s AND bar = %d", 'hello', 99 ]
+    def self.construct_sql_for_array(a)
+      format, *values = a
+      if format.include?("\?")
+        raise ArgumentError unless format.count('\?') == values.size # sanity check right number args
+        format.gsub(/\?/) { quote_value(values.shift.to_s) }         # replace all ? with args
+      elsif format.blank?
+        format
+      else # replace sprintf escapes
+        format % values.collect { |value| quote_value(value.to_s) }
+      end
+    end
+
+    ## Construct string of conditions from a hash of format plus values to substitute.
+    ## Allows conditions as hash of key/value pairs to be ANDed together.
+    ## Examples:
+    ##   { :foo => :hello, :bar => 99 }
+    def self.construct_sql_for_hash(h)
+      h.map{|k,v| "#{k}=#{quote_value(v.to_s)}"}.join(' AND ')
+    end
+
+    ## Calls find and returns array of all matches.
+    def self.all(*args)
+      find(:all, *args)
+    end
+
+    ## Calls find and returns first matching object.
+    def self.first(*args)
+      find(:first, *args)
+    end
+
+    ## Calls find and returns last matching object.
+    def self.last(*args)
+      find(:last, *args)
+    end
+
+    ## Find takes a list of conditions as a hash, and returns array of matching objects.
+    ## If single argument is numeric, return first object to match by primary key.
+    def self.find(*arguments)
+      scope   = arguments.slice!(0)
+      options = arguments.slice!(0) || {}
+
+      case scope
+      when :all   then find_every(options)          # Employee.find(:all,   :conditions => 'team_id = 156')
+      when :first then find_every(options).first    # Employee.find(:first, :conditions => 'team_id = 156')
+      when :last  then find_every(options).last     # Employee.find(:last,  :conditions => 'team_id = 156')
+      else             find_single(scope, options)  # Employee.find(7923113)
+      end
+    end
+
+    ## Return array of columns to use for SELECT statements, ensuring we get primary_key, or single
+    ## string '*' if no columns set.
+    def self.columns_or_default
+      columns.empty? ? '*' : ([primary_key]+columns).uniq
+    end
+
+    ## Find array of all matching records.
+    def self.find_every(options)
+      defaults = { :select => columns_or_default, :from => table_name }
+      sql = construct_sql(defaults.merge(options))
+      find_by_sql(sql)
+    end
+
+    ## Find a single record with given primary key.
+    def self.find_single(scope, options)
+      defaults = { :select => columns_or_default, :from => table_name, :conditions => {primary_key => scope} }
+      sql = construct_sql(defaults)
+      find_by_sql(sql).first
+    end
+
+    ## Return string with whole URL for request, adding given SQL string as query.
+    def self.construct_url_for_sql(sql)
+      (host, port, path) = ATOMICS_CONFIG[atomics_type.to_s].values_at('host', 'port', 'path')
+      "http://#{host}:#{port}#{path}&q=#{URI.escape(sql)}"      
+    end
+
+    ## Find matches using raw SQL statement given as a string.
+    ## args:: string containing SQL statement.
+    ## returns:: array of objects.
+    def self.find_by_sql(sql)
+      url = construct_url_for_sql(sql)
+
+      ## get the xml doc as a nokogiri object
+      doc = Nokogiri::XML(open(url))
+      
+
+      ## array of records
+      records = doc.xpath('//record').to_a.map do |record|
+        
+        ## convert record into a hash with name => value
+        hash = record.xpath('./field').inject({}) do |hash, field|
+          hash[field.xpath('./name')[0].content] = field.xpath('./value')[0].content
+          hash
+        end
+
+        ## instantiate record object
+        new(hash)
+      end
+
+    end
+
+    ## What uses this?
+    def self.to_model
+      self
+    end
+
+    ## instance variables
+    attr_accessor :attributes
+
+    ## Constructor allows hash as arg to set attributes.
+    def initialize(attributes = {})
+      hsh = {}
+      @attributes = hsh.respond_to?(:with_indifferent_access) ? hsh.with_indifferent_access : hsh
+      load(attributes)
+    end
+
+    ## Set attributes for an existing instance of this object.
+    def load(attributes)
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      attributes.each do |key, value|
+        @attributes[key.to_s] = value.dup rescue value
+      end
+      self
+    end
+
+    ## Return formatted inspection string for record with attributes listed.
+    def inspect
+      attributes_string = @attributes.map{|k,v| "#{k}: #{value_for_inspect(v)}"}.join(', ')
+      "#<#{self.class} #{attributes_string}>"
+    end
+
+    ## Returns inspect for a value, with strings shortened to 50 chars, for use in Object.inspect.
+    def value_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      else
+        value.inspect
+      end
+    end
+
+    ## Get attributes as methods, like active_model.
+    def method_missing(method_symbol, *arguments)
+      method_name = method_symbol.to_s
+      if method_name =~ /=$/
+        attributes[$`] = arguments.first
+      elsif method_name =~ /\?$/
+        attributes[$`]
+      else
+        return attributes[method_name] if attributes.include?(method_name)
+        super
+      end
+    end
+
+    ## Get attributes using hash syntax.
+    def [](attr)
+      attributes[attr]
+    end
+
+    ## Value of primary key.
+    def id
+      attributes[self.class.primary_key].to_i
+    end
+
+    ## What uses this?
+    def to_key
+      [id]
+    end
+
+    ## Return primary_key as param for object, for polymorphic route generation to work from object in view.
+    def to_param
+      attributes[self.class.primary_key]
+    end
+
+  end
+
+  ## Do some mix-ins to get various bits of rails coolness, skip these for non-rails.
+  if defined? RAILS_ROOT
+    extend ActiveModel::Naming  # need this for model_name and variants, used to get paths from objects
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'atomics_resource'

data/test/spec_atomics_resource.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+# ATOMICS_CONFIG = YAML.load_file("atomics.yml")
+
+ATOMICS_CONFIG = {
+  'my_type' => {
+    'host' => 'orb-atomics.ops.aol.com',
+    'port' => '8080',
+    'path' => '/jAtomics/select/?version=1'
+  }
+}
+
+module AtomicsResource
+  describe Base do
+    before :each do
+      class MyTest < AtomicsResource::Base
+        set_atomics_type :my_type
+        set_table_name   :my_table
+        set_primary_key  :my_pk
+      end
+    end
+
+    context "class variables" do
+      it "should have class settings" do
+        MyTest.atomics_type.should == :my_type
+        MyTest.table_name.should   == :my_table
+        MyTest.primary_key.should  == :my_pk
+      end
+    end
+
+    context "atomics config" do
+      require 'uri'
+      it "should create a valid base URL" do
+        sql = "select * from foo where bar = 'wibble'"
+        URI.parse(MyTest.construct_url_for_sql(sql)).class.should == URI::HTTP
+      end
+    end
+
+    context "sql construction" do
+      it "should construct sql from array conditions" do
+        a = MyTest.construct_sql_for_conditions(["foo = \? AND bar = \?", :hello, :world])
+        a.should == "foo = 'hello' AND bar = 'world'"
+      end
+      it "should contruct sql from hash conditions" do
+        b = MyTest.construct_sql_for_conditions({:foo => :hello, :bar => :world})
+        b.should == "foo='hello' AND bar='world'"
+      end
+    end
+
+  end
+
+end

data/test/test_atomics_resource.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestAtomicsResource < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: atomics_resource
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Richard Lister
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: Model Atomics (MySQL over HTTP) records for ruby and rails projects
+email: rlister@github
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/employees.rb
+- lib/atomics_resource.rb
+- lib/atomics_resource/base.rb
+- test/helper.rb
+- test/spec_atomics_resource.rb
+- test/test_atomics_resource.rb
+homepage: http://github.com/rlister/atomics_resource
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1985330703577403544
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Active Model for Atomics MySQL lookups
+test_files: []
+