rubysync 0.0.1

data/bin/rubysync

@@ -0,0 +1,312 @@
+#!/opt/local/bin/ruby
+
+
+  # == Synopsis
+  # 
+  #   Command line tool for running *rubysync* <em>A Free MetaDirectory.</em>
+  # 
+  # == Usage
+  #   
+  #     rubysync command name [options]
+  #   
+  #  Valid commands are::
+  #   * create {name}::            Create a rubysync configuration directory
+  # 
+  #   * connector {name} -t {type} [--vault {name}] [--client {name}]
+  #                           ; Create a connector of the given name in
+  #                           ; the current rubysync configuration directory
+  #                         
+  #   * fields {name}           ; list the fields detected by the named connector
+  # 
+  #   * pipeline {name}         ; Create a rubysync pipeline of the given name
+  #                           ; in the current rubysync configuration directory
+  #                         
+  #   * once {name}::             
+  #       Execute the named pipeline within the current configuration directory once and then exit
+  #                         
+  #   * example::          Show an example of how this command might be used
+  # 
+  # == Example
+  # 
+  #   This sets up the skeleton of a configuration for importing comma delimeted
+  #   text files into a database. Note, if the application happens to be a Rails app
+  #   then it can also export changes.
+  #     <tt>
+  #     $ rubysync create db_demo
+  #     $ cd db_demo
+  #     $ rubysync connector my_csv -t csv_file
+  #     $ rubysync connector my_db -t active_record
+  #     </tt>
+  #   
+  #   You would then edit the files::
+  # 
+  #     * +connectors/my_csv_connector.rb+:: where to get the CSV files, field names, etc
+  #     * +connectors/my_db_connector.rb+::  how to connect to your database or Rails app.
+  # 
+  #   And enter::
+  #     <tt>
+  #     $ rubysync pipeline my_pipeline -C my_csv -V my_db
+  #     </tt>
+  # 
+  #   You would then edit the file +pipelines/my_pipeline.rb+ to configure the
+  #   policy for synchronizing between the two connectors.
+  #                                         
+  #   You may then execute the pipeline in one-shot mode (daemon mode is coming)::
+  # 
+  #     <tt>
+  #     $ rubysync once my_pipeline
+  #     </tt>
+  # 
+  # == Author
+  #   Ritchie Young, 9 to 5 Magic (http://9to5magic.com.au)
+  #  
+  # == Copyright
+  #   Copyright (c) 2007 Ritchie Young. All rights reserved.
+  # 
+  # This file is part of RubySync.
+  # 
+  # RubySync is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+  # as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
+  # 
+  # RubySync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+  # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+  # 
+  # You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
+  # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+
+lib_path = File.dirname(__FILE__) + '/../lib'
+$:.unshift lib_path unless $:.include?(lib_path) || $:.include?(File.expand_path(lib_path))
+require "ruby_sync"
+require "simpleconsole"
+require 'rdoc/usage'
+
+
+class Controller < SimpleConsole::Controller
+
+  include RubySync::Utilities
+
+  before_filter :configure_logging
+  
+  params :string => {:p => :pipe,
+                     :t => :type,
+                     :V => :vault,
+                     :C => :client},
+         :int =>{:v => :verbose}
+
+  def default
+    #RDoc::usage 'Usage'
+  end
+  
+  def example
+    #RDoc::usage 'Example'
+  end
+  
+  # Run specified pipeline once then exit
+  def once
+    pipeline_name = params[:id]
+    pipeline = pipeline_called pipeline_name
+    if pipeline
+      pipeline.run_once
+    else
+      log.error "Couldn't find a pipeline called '#{pipeline_name}'"
+    end
+  end
+
+  # Create a Rubysync project directory
+  def create
+    config_path = params[:id]
+    ensure_dir_exists config_path
+    ensure_dir_exists config_path + "/pipelines"
+    ensure_dir_exists config_path + "/connectors"  
+  end
+  
+  # Create a connector configuration file
+  def connector
+    name = params[:id]
+    type = params[:type]
+    unless name and type
+      puts "Usage: rubysync connector connector_name -t connector_type"
+      return
+    end
+    if base_path
+      File.open("#{base_path}/connectors/#{name}_connector.rb", "w") do |file|
+        file.puts connector_template(name, type)
+      end
+    else
+      puts 'Change into a config dir and try again or create a config dir with "rubysync create"'
+    end
+  end
+
+  # List the fields that the named connector can detect. This is
+  # a good way to test if a connector config is functional.
+  def fields
+    connector_name = params[:id]
+    connector = (connector_name)? ::RubySync::Connectors::BaseConnector.class_for(connector_name) : nil
+    @field_names = connector && connector.fields || []
+  end
+  
+  def pipeline
+    name = params[:id]
+    vault_name = params[:vault]
+    client_name = params[:client]
+    unless name
+      puts "Usage: rubysync pipeline pipeline_name [-V vault] [-C client]"
+      return
+    end
+    if base_path
+      File.open("#{base_path}/pipelines/#{name}_pipeline.rb", "w") do |file|
+        file.puts pipeline_template(name, vault_name, client_name)
+      end
+    else
+      puts 'Change into a config dir and try again or create a config dir with "rubysync create"'
+    end
+    
+  end
+  
+  
+  private
+  
+  def configure_logging
+    log_levels = [Logger::WARN, Logger::INFO, Logger::DEBUG]
+    verbosity = [(params[:verbose]||0), log_levels.size-1].min
+    log.level = log_levels[verbosity]
+  end
+  
+end
+
+
+class View < SimpleConsole::View
+
+
+def default
+puts <<"END"
+Usage:
+  
+    rubysync command name [options]
+  
+ Valid commands are:
+  * create {name}:            Create a rubysync configuration directory
+
+  * connector {name} -t {type} [--vault {name}] [--client {name}]
+                          ; Create a connector of the given name in
+                          ; the current rubysync configuration directory
+                        
+  * fields {name}         ; list the fields detected by the named connector
+
+  * pipeline {name}       ; Create a rubysync pipeline of the given name
+                          ; in the current rubysync configuration directory
+                        
+  * once {name}             
+                          ; Execute the named pipeline within the current
+                          ; configuration directory once and then exit
+                        
+  * example               ; Show an example of how this command might be used
+
+END
+end
+
+
+def example
+puts <<"END"
+  This sets up the skeleton of a configuration for importing comma delimeted
+  text files into a database. Note, if the application happens to be a Rails
+  app then it can also export changes.
+
+    $ rubysync create db_demo
+    $ cd db_demo
+    $ rubysync connector my_csv -t csv_file
+    $ rubysync connector my_db -t active_record
+  
+  You would then edit the files:
+
+    connectors/my_csv_connector.rb   ;where to get CSV files, field names, etc
+    connectors/my_db_connector.rb    ;how to connect to your DB or Rails app.
+
+  And enter:
+    $ rubysync pipeline my_pipeline -C my_csv -V my_db
+
+  You would then edit the file +pipelines/my_pipeline.rb+ to configure the
+  policy for synchronizing between the two connectors.
+                                        
+  You may then execute the pipeline in one-shot mode (daemon mode is coming):
+
+    $ rubysync once my_pipeline
+END
+end
+
+def fields
+  puts @field_names.join("\n")
+end
+
+                                            
+  
+  def start
+    puts "Not yet implemented"
+  end
+
+end
+
+
+  def connector_template name, type
+    type_class_name = "RubySync::Connectors::#{type.to_s.camelize}Connector"
+    type_class = eval(type_class_name)
+    sample_config = (type_class && type_class.respond_to?("sample_config")) ?
+      type_class.sample_config : ""
+    return <<-"end;"
+class #{name.to_s.camelize}Connector < #{type_class_name}
+  #{sample_config}
+end
+    end;
+  end
+  
+
+  
+  def pipeline_template name, vault_name, client_name
+    vault = (vault_name)? ::RubySync::Connectors::BaseConnector.class_for(vault_name) : nil
+    vault_fields = vault && vault.fields || %w{allow these fields through}
+    possible_fields = (vault_fields.map {|n| ":#{n}"}).join(", ")
+
+    client = (client_name)? ::RubySync::Connectors::BaseConnector.class_for(client_name) : nil
+    client_fields = client && client.fields || []
+
+    vault_specifier = (vault_name)? "vault :#{vault_name}" : "#vault :vault_connector_name"
+    client_specifier = (client_name)? "client :#{client_name}" : "#client :client_connector_name"
+    return <<-"end;"
+class #{name.to_s.camelize}Pipeline < RubySync::Pipelines::BasePipeline
+
+  #{client_specifier}
+
+  #{vault_specifier}
+
+  # Remove any fields that you don't want to set in the client from the vault
+  allow_out #{possible_fields}
+
+  # Remove any fields that you don't want to set in the vault from the client
+  allow_in #{possible_fields}
+
+  # If the client and vault have different names for the same field, define the
+  # the mapping here. For example, if the vault has a field called "first name" and
+  # the client has a field called givenName you may put:
+  #    'first name' => 'givenName'
+  # separate each mapping with a comma.
+  # The following fields were detected on the client:
+  # #{(client_fields.map {|f| "'#{f}'"}).join(", ")}
+  map_vault_to_client(
+    #{(vault_fields.map {|f| "#'#{f}' => 'a_client_field'"}).join(",\n\t\t")}
+  )
+
+  # "in" means going from client to vault
+  #in_transform do
+  #end
+
+  # "out" means going from vault to client
+  #out_transform do
+  #end
+
+end
+    end;
+  end
+
+
+SimpleConsole::Application.run(ARGV, Controller, View)

data/examples/ar_client_webapp/README

@@ -0,0 +1,182 @@
+== Welcome to Rails
+
+Rails is a web-application and persistence framework that includes everything
+needed to create database-backed web-applications according to the
+Model-View-Control pattern of separation. This pattern splits the view (also
+called the presentation) into "dumb" templates that are primarily responsible
+for inserting pre-built data in between HTML tags. The model contains the
+"smart" domain objects (such as Account, Product, Person, Post) that holds all
+the business logic and knows how to persist themselves to a database. The
+controller handles the incoming requests (such as Save New Account, Update
+Product, Show Post) by manipulating the model and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails.  You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting started
+
+1. At the command prompt, start a new rails application using the rails command
+   and your application name. Ex: rails myapp
+   (If you've downloaded rails in a complete tgz or zip, this step is already done)
+2. Change directory into myapp and start the web server: <tt>script/server</tt> (run with --help for options)
+3. Go to http://localhost:3000/ and get "Welcome aboard: You’re riding the Rails!"
+4. Follow the guidelines to start developing your application
+
+
+== Web Servers
+
+By default, Rails will try to use Mongrel and lighttpd if they are installed, otherwise
+Rails will use the WEBrick, the webserver that ships with Ruby. When you run script/server,
+Rails will check if Mongrel exists, then lighttpd and finally fall back to WEBrick. This ensures
+that you can always get up and running quickly.
+
+Mongrel is a Ruby-based webserver with a C-component (which requires compilation) that is
+suitable for development and deployment of Rails applications. If you have Ruby Gems installed,
+getting up and running with mongrel is as easy as: <tt>gem install mongrel</tt>.
+More info at: http://mongrel.rubyforge.org
+
+If Mongrel is not installed, Rails will look for lighttpd. It's considerably faster than
+Mongrel and WEBrick and also suited for production use, but requires additional
+installation and currently only works well on OS X/Unix (Windows users are encouraged
+to start with Mongrel). We recommend version 1.4.11 and higher. You can download it from
+http://www.lighttpd.net.
+
+And finally, if neither Mongrel or lighttpd are installed, Rails will use the built-in Ruby
+web server, WEBrick. WEBrick is a small Ruby web server suitable for development, but not
+for production.
+
+But of course its also possible to run Rails on any platform that supports FCGI.
+Apache, LiteSpeed, IIS are just a few. For more information on FCGI,
+please visit: http://wiki.rubyonrails.com/rails/pages/FastCGI
+
+
+== Debugging Rails
+
+Have "tail -f" commands running on the server.log and development.log. Rails will
+automatically display debugging and runtime information to these files. Debugging
+info will also be shown in the browser on requests from 127.0.0.1.
+
+
+== Breakpoints
+
+Breakpoint support is available through the script/breakpointer client. This
+means that you can break out of execution at any point in the code, investigate
+and change the model, AND then resume execution! Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.find(:all)
+      breakpoint "Breaking out from the list"
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the breakpointer window. Here you can do things like:
+
+Executing breakpoint "Breaking out from the list" at .../webrick_server.rb:16 in 'breakpoint'
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8 @attributes={\"title\"=>nil, \"body\"=>nil, \"id\"=>\"1\"}>,
+       #<Post:0x14a6620 @attributes={\"title\"=>\"Rails you know!\", \"body\"=>\"Only ten..\", \"id\"=>\"2\"}>]"
+  >> @posts.first.title = "hello from a breakpoint"
+  => "hello from a breakpoint"
+
+...and even better is that you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you press CTRL-D
+
+
+== Console
+
+You can interact with the domain model by starting the console through <tt>script/console</tt>.
+Here you'll have all parts of the application configured, just like it is when the
+application is running. You can inspect domain models, change values, and save to the
+database. Starting the script without arguments will launch it in the development environment.
+Passing an argument will specify a different environment, like <tt>script/console production</tt>.
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+
+
+== Description of contents
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from ApplicationController
+  which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb.
+  Most models will descend from ActiveRecord::Base.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.rhtml for the WeblogsController#index action. All views use eRuby
+  syntax.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the common
+  header/footer method of wrapping views. In your views, define a layout using the
+  <tt>layout :default</tt> and create a file named default.rhtml. Inside default.rhtml,
+  call <% yield %> to render the view using this layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are generated
+  for you automatically when using script/generate for controllers. Helpers can be used to
+  wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database, and other dependencies.
+
+components
+  Self-contained mini-applications that can bundle together controllers, models, and views.
+
+db
+  Contains the database schema in schema.rb.  db/migrate contains all
+  the sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when generated
+  using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that doesn't
+  belong under controllers, models, or helpers. This directory is in the load path.
+
+public
+  The directory available for the web server. Contains subdirectories for images, stylesheets,
+  and javascripts. Also contains the dispatchers and the default HTML files. This should be
+  set as the DOCUMENT_ROOT of your web server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the script/generate scripts, template
+  test files will be generated for you and placed in this directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins subdirectory.
+  This directory is in the load path.

data/examples/ar_client_webapp/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'

data/examples/ar_client_webapp/app/controllers/application.rb

@@ -0,0 +1,7 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  # Pick a unique cookie name to distinguish our session data from others'
+  session :session_key => '_ar_client_webapp_session_id'
+end

data/examples/ar_client_webapp/app/controllers/user_controller.rb

@@ -0,0 +1,5 @@
+class UserController < ApplicationController
+  
+  scaffold 'User'
+  
+end

data/examples/ar_client_webapp/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/examples/ar_client_webapp/app/helpers/user_helper.rb

@@ -0,0 +1,2 @@
+module UserHelper
+end

data/examples/ar_client_webapp/app/models/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/examples/ar_client_webapp/config/boot.rb

@@ -0,0 +1,45 @@
+# Don't change this file. Configuration is done in config/environment.rb and config/environments/*.rb
+
+unless defined?(RAILS_ROOT)
+  root_path = File.join(File.dirname(__FILE__), '..')
+
+  unless RUBY_PLATFORM =~ /(:?mswin|mingw)/
+    require 'pathname'
+    root_path = Pathname.new(root_path).cleanpath(true).to_s
+  end
+
+  RAILS_ROOT = root_path
+end
+
+unless defined?(Rails::Initializer)
+  if File.directory?("#{RAILS_ROOT}/vendor/rails")
+    require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+  else
+    require 'rubygems'
+
+    environment_without_comments = IO.readlines(File.dirname(__FILE__) + '/environment.rb').reject { |l| l =~ /^#/ }.join
+    environment_without_comments =~ /[^#]RAILS_GEM_VERSION = '([\d.]+)'/
+    rails_gem_version = $1
+
+    if version = defined?(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION : rails_gem_version
+      # Asking for 1.1.6 will give you 1.1.6.5206, if available -- makes it easier to use beta gems
+      rails_gem = Gem.cache.search('rails', "~>#{version}.0").sort_by { |g| g.version.version }.last
+
+      if rails_gem
+        gem "rails", "=#{rails_gem.version.version}"
+        require rails_gem.full_gem_path + '/lib/initializer'
+      else
+        STDERR.puts %(Cannot find gem for Rails ~>#{version}.0:
+    Install the missing gem with 'gem install -v=#{version} rails', or
+    change environment.rb to define RAILS_GEM_VERSION with your desired version.
+  )
+        exit 1
+      end
+    else
+      gem "rails"
+      require 'initializer'
+    end
+  end
+
+  Rails::Initializer.run(:set_load_path)
+end

data/examples/ar_client_webapp/config/database.yml

@@ -0,0 +1,36 @@
+# MySQL (default setup).  Versions 4.1 and 5.0 are recommended.
+#
+# Install the MySQL driver:
+#   gem install mysql
+# On MacOS X:
+#   gem install mysql -- --include=/usr/local/lib
+# On Windows:
+#   gem install mysql
+#       Choose the win32 build.
+#       Install MySQL and put its /bin directory on your path.
+#
+# And be sure to use new-style password hashing:
+#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
+development:
+  adapter: mysql
+  database: ar_client_webapp_development
+  username: root
+  password:
+  socket: /tmp/mysql.sock
+
+# Warning: The database defined as 'test' will be erased and
+# re-generated from your development database when you run 'rake'.
+# Do not set this db to the same as development or production.
+test:
+  adapter: mysql
+  database: ar_client_webapp_test
+  username: root
+  password:
+  socket: /tmp/mysql.sock
+
+production:
+  adapter: mysql
+  database: ar_client_webapp_production
+  username: root
+  password: 
+  socket: /tmp/mysql.sock

data/examples/ar_client_webapp/config/environment.rb

@@ -0,0 +1,60 @@
+# Be sure to restart your web server when you modify this file.
+
+# Uncomment below to force Rails into production mode when 
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '1.2.3' unless defined? RAILS_GEM_VERSION
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here
+  
+  # Skip frameworks you're not going to use (only works if using vendor/rails)
+  # config.frameworks -= [ :action_web_service, :action_mailer ]
+
+  # Only load the plugins named here, by default all plugins in vendor/plugins are loaded
+  # config.plugins = %W( exception_notification ssl_requirement )
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Force all environments to use the same logger level 
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Use the database for sessions instead of the file system
+  # (create the session table with 'rake db:sessions:create')
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper, 
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector
+
+  # Make Active Record use UTC-base instead of local time
+  # config.active_record.default_timezone = :utc
+  
+  # See Rails::Configuration for more options
+end
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register "application/x-mobile", :mobile
+
+# Include your application configuration below