dm-cutie-ui 0.0.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2009, Cory ODaniel 
+
+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.markdown

@@ -0,0 +1,61 @@
+Description
+=============
+dm-cutie-ui is a live reporting tool for dm-cutie. http://github.com/coryodaniel/dm-cutie
+
+
+Adding Custom Columns
+======================
+  The partial 'grid' takes three keys to create its local variables: :columns, :records, :adhoc_columns (discussed next)
+  
+  Columns should be respond to #each, it will generally be a DataMapper PropertySet. Each element in columns will be used in a #send method call on each of the elements in records. That means instead of doing the standard
+      partial :grid, :locals => { :columns => MyModel.properties, :records => @my_collection}
+      
+  You can add any other columns you want as long as there is a method that a 'record' will respond to. For example, every object has a 'class' method, so you could do
+      partial :grid, 
+        :locals => { 
+          :columns => MyModel.properties.to_a + [:class],
+          :records => @my_collection
+        }
+  
+  This would cause the class name to be output in a column (pretty useless), but you can add any method you want to the class and simply add its name to the set of elements being passed to :columns
+  
+  
+  As an alternative method you can pass a column name to a proc in the :adhoc_columns parameter
+    partial :grid,
+      :locals => {
+        :columns => MyModel.properties,
+        :records => @my_collection,
+        :adhoc_columns => {
+          :my_cool_class_name => lambda{|my_record| my_record.class }
+        }
+      }
+      
+  This would result in a column named 'my_cool_class_name' with a value of 'MyModel'. Obviously you can be more creative :)
+  
+  Note: the proc should accept one parameter, the specific record from the collection of items passed to :records
+  
+  IMPORTANT NOTE:
+    Remember, if you are adding additional columns to the grid, make sure you pass the column names to the 'menu' partial if you want the ability to hide that column.
+
+
+DataMapper Default Context
+==========================
+DataMapper requires a 'default' repository.  In DM UI all users use their own repository, so a fake repository is stubbed as
+
+    DataMapper.setup :default, "abstract://null"
+    
+All calls should be done through the Sinatra helper method #repo.
+
+
+TODOS
+===== 
+  * If you boot a server with extras and then browse to a dm-cutie repo with out those extras you get an error
+    * should probably change extras loaded to a 'per repository' thing
+  * Make *.erbs more dry, its probably possible to get ride of them all together if the hooks had the following methods display_views, display_relationships
+  * Make this app less ugly, I suck horribly at CSS :)  
+    * Deal w/ the super fields
+  * --include-hooks=this,that/there,etc
+    * figure out how to support including hooks/views that aren't a part of dm-cutie or dm-cutie-extras
+  * dm-pagination
+  * If someone built a merb-slice version of this, they would be awesome.
+  * Sinatra shutdown hook to clean up the tmp directory

data/Rakefile

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'merb-core/version'
+require 'merb-core/tasks/merb_rake_helper'
+require "extlib"
+
+require 'rake'
+require 'rake/clean'
+require 'spec/rake/spectask'
+require "spec"
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+ROOT    = Pathname(__FILE__).dirname.expand_path
+require ROOT + 'lib/dm-cutie-ui/version'
+
+@spec = Gem::Specification.new do |s|
+  s.name = %q{dm-cutie-ui}
+  s.version = DmCutieUI::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors     = ["Cory ODaniel"]
+  s.date        = %q{2009-10-15}
+  s.summary = s.description = %q{An interface to DM Cutie repos.}
+  s.email = %q{cutie@coryodaniel.com}
+  s.bindir = 'bin'
+  s.executables = ['dm-cutie-ui']
+  s.extra_rdoc_files = ["README.markdown", "LICENSE", "History.txt"]
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "History.txt",
+    "config.ru",
+    "bin/dm-cutie-ui",
+    "lib/dm-cutie-ui.rb",
+    "lib/dm-cutie-ui/config.rb",    
+    "lib/dm-cutie-ui/server.rb",    
+    "lib/dm-cutie-ui/version.rb",    
+  ]
+  s.files += Dir["lib/dm-cutie-ui/server/**/*"]
+  s.has_rdoc = true
+  s.homepage = "http://github.com/coryodaniel/dm-cutie-ui"
+
+  s.add_dependency 'sinatra',       '=0.9.4'
+  s.add_dependency 'extlib',        ">=0.9.13"
+  s.add_dependency "dm-core",       ">=0.10.1"
+  s.add_dependency "dm-aggregates", ">=0.10.1"
+  s.add_dependency "data_objects",  '>=0.10.0'
+  s.add_dependency "dm-cutie",      '>=0.3.0'
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.2.0}
+end
+
+[ ROOT, ROOT.parent ].each do |dir|
+  Pathname.glob(dir.join('tasks/**/*.rb').to_s).each { |f| require f }
+end
+
+NAME = @spec.name
+GEM_VERSION = DmCutieUI::VERSION
+
+Rake::GemPackageTask.new(@spec) do |pkg|
+  pkg.gem_spec = @spec
+end
+
+desc "install the plugin locally"
+task :install => [:package] do
+  sh %{sudo gem install #{install_home} pkg/#{NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{NAME}.gemspec", "w") do |file|
+    file.puts @spec.to_ruby
+  end
+end
+
+Rake::RDocTask.new do |rdoc|
+  files = ["README.markdown", "History.txt", "LICENSE", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.markdown"
+  rdoc.title = "DM CutieUI"
+
+  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.options << "--line-numbers" << "--inline-source"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = Dir["./spec/**/*_spec.rb"]
+  t.spec_files.unshift './spec/spec_helper.rb'
+  
+  t.libs = ['lib']
+  t.spec_opts << "--color" << "--format" << "specdoc" #"progress"
+  
+  if ENV['RCOV']
+    t.rcov = true
+    t.rcov_opts << '--exclude' << 'pkg,spec,interactive.rb,install_test_suite.rb,lib/gems,' + Gem.path.join(',')
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    t.rcov_opts << '--only-uncovered'
+  end
+end

data/bin/dm-cutie-ui

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+require 'rubygems' #its poison, i know.
+
+if `which rackup`.empty?
+  abort "** Can't find `rackup` in PATH."
+end
+
+if ARGV.include?('-h') || ARGV.include?('--help')
+  puts <<-USAGE_INFO
+Usage: dm-cutie-ui [cutie-options] [ruby-options] [rack-options]
+
+Starts the dm-cutie front end
+
+DmCutieUI Options:
+==================================================
+  --extras= # A comma seperated list of extras for dm-cutie to look for 
+    (should match what you had in your app)
+    Examples: 
+      dm-cutie-ui --extras=sqlite3_execution_plan
+      dm-cutie-ui --extras=mysql_execution_plan,mysql_warning
+
+Rack Options:
+==================================================
+  -s, --server SERVER      serve using SERVER (webrick/mongrel)
+  -o, --host HOST          listen on HOST (default: 0.0.0.0)
+  -p, --port PORT          use PORT (default: 9292)
+  -E, --env ENVIRONMENT    use ENVIRONMENT for defaults (default: development)
+  -D, --daemonize          run daemonized in the background
+  -P, --pid FILE           file to store PID (default: rack.pid)
+  
+USAGE_INFO
+
+else
+  __DIR__ = File.expand_path( File.join(File.dirname(__FILE__), '..') )
+  
+  # Simple ARGV Parser, @note include-hooks is a TODO
+  #   Remove cutie's argv from ARGV and let Sinatra have it.
+  cutie_flags = [:extras, :'include-hooks']
+  cutie_argv = ARGV.select{|arg| arg =~ /(\-\-(#{cutie_flags.join('|')}))/}
+  ARGV.delete_if{|arg| cutie_argv.member?(arg)}
+
+  args = ARGV
+  ENV['RUBYLIB'] = ENV['RUBYLIB'].to_s + ':' + File.join(__DIR__,'lib')
+  args.unshift '-e', %Q{require "dm-cutie-ui"; CUTIE_ARGV=%w{#{cutie_argv.join(' ')}}}
+  args.push File.expand_path(
+    File.join(__DIR__, "config.ru")
+  )
+
+  exec "rackup", *args
+end

data/config.ru

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+ 
+$LOAD_PATH.unshift File.expand_path(
+  File.join(File.dirname(__FILE__), 'lib')
+)
+require 'dm-cutie-ui/config'
+require 'dm-cutie-ui/server'
+
+use Rack::ShowExceptions
+run DmCutieUI::Server.new

data/lib/dm-cutie-ui.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'digest/md5'
+require 'logger'
+
+gem 'extlib', ">=0.9.13"
+require 'extlib'
+   
+gem 'dm-cutie', '>=0.3.0'
+require 'dm-cutie'
+
+gem 'dm-aggregates', '>=0.10.1'
+require 'dm-aggregates'
+
+gem 'dm-core', '>=0.10.1'
+require 'dm-core'
+
+gem "data_objects",  '>=0.10.0'
+require 'data_objects'
+
+# SEt up a faux adapter. DM requires a default repository
+#   Repository names are hashes of the Normalized URI and are stored in CutieUI.
+DataMapper.setup :default, "abstract://null"
+
+module DmCutieUI
+  class << self
+    def logger
+      @_logger ||= Logger.new(STDOUT)
+    end
+    def view_root
+      @_view_root ||= File.join('', 'tmp', 'dm-cutie-ui', Time.now.to_i.to_s)
+    end
+    # - routes - Routes for cutie models
+    #
+    def routes
+      @__routes ||={}
+    end
+    
+    # - repos - Cache of connection strings used since boot time
+    # 
+    # @return [String] connection string
+    def repos
+      @__repos ||= {}
+    end
+    
+    # - connect - Connects to a datamapper repository
+    #   This takes the password as an additional parameter for 'security' reasons since
+    #   it caches all connection strings for a user
+    #
+    # @param connection [Hash]
+    #   - string    [String] connection string
+    #   - password  [String] connection password
+    #
+    # @return [String] - 
+    #
+    def connect( connection )        
+      connection_options = DataMapper::Adapters.send(:normalize_options, connection[:string])
+
+      # Cache this before adding the password if the person decided they didn't want it cached by leaving it out
+      normalized_uri = begin
+        query = connection_options.except(:adapter, :user, :password, :host, :port, :path, :fragment, :scheme, :query, :username, :database)
+        query = nil if query.empty?
+
+        DataObjects::URI.new(
+          connection_options[:adapter],
+          connection_options[:user] || connection_options[:username],
+          nil, #Dont put the password in the cache
+          connection_options[:host],
+          connection_options[:port],
+          connection_options[:path] || connection_options[:database],
+          query,
+          connection_options[:fragment]
+        )
+      end
+      
+      # Create a hash of the normalized_uri
+      token   = Digest::MD5.hexdigest(normalized_uri.to_s).to_sym
+
+      # Cache the uri
+      DmCutieUI.repos[token] = normalized_uri.to_s
+
+      # Add the password if it was provided
+      connection_options[:password] = connection[:password] unless connection[:password].blank?
+      
+      adapter = DataMapper::Adapters.new token, connection_options
+
+      DataMapper::Repository.adapters[adapter.name] = adapter
+      
+      if DataMapper::Cutie.valid_repo? adapter.name
+        return token
+      else
+        return false
+      end
+    end
+    
+    def root
+      @_root_path ||= File.expand_path(File.dirname(__FILE__)) / 'dm-cutie-ui'
+    end
+  end
+end
+
+require DmCutieUI.root / :version
+
+class String
+  def truncate(len,repl='...')
+    (self.length <= (len - repl.length)) ? self : self.slice(0,len) + repl.to_s
+  end
+end

data/lib/dm-cutie-ui/config.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+puts CUTIE_ARGV
+
+cutie_ui_config = CUTIE_ARGV.inject({}) do |conf, arg|
+  config_key, config_vals = arg.split('=')
+
+  if config_key
+    # { :extras => ['mysql', 'sqlite3'] }
+    config_value = config_vals.blank? ? true : config_vals.split(',')
+
+    conf[config_key.gsub('--','').to_sym] = config_value
+    conf
+  else
+    conf
+  end
+end
+
+
+# dm-cutie-ui has a bunch of views, but views may also come from dm-cutie-extras and eventually add'l plugins
+#   since we need a path to all the views, we create a temp folder and copy the views their
+#   as well as any other views from additional gems/reqs
+
+# Configure DmCutieUI
+FileUtils.mkdir_p DmCutieUI.view_root
+FileUtils.cp_r(
+  File.join(DmCutieUI.root, "server", "views"), DmCutieUI.view_root
+)
+DmCutieUI.logger.info "View temp directory: #{DmCutieUI.view_root}"
+
+
+# If extras were requested, get them.
+if cutie_ui_config[:extras]
+  begin
+    require 'dm-cutie-extras'
+  rescue LoadError => ex
+    DmCutieUI.logger.error "dm-cutie-extras were requested, but the gem was not found: gem install dm-cutie-extras"
+    exit(1)
+  end
+  
+  cutie_ui_config[:extras].each do |extra|
+    begin
+      # Load the extra
+      DataMapper::Cutie::Extras.load extra.to_sym
+    
+      # move the hook's view into the DmCutieUI.view_root/cutie_models directory
+      #/tmp/dm-cutie-ui/view/1258150564/views/cutie_models/#{extra}.erb
+      # render a extras views by doing
+      # render :'cutie_models/#{extra}'
+    
+      FileUtils.cp DataMapper::Cutie::Extras.view_path[extra.to_sym], DmCutieUI.view_root / 'views' / 'cutie_models'
+    rescue LoadError => ex
+      DmCutieUI.logger.error "dm-cutie-extra '#{extra}' does not exist."
+      exit(2)
+    end
+  end  
+end
+
+# Thanks to dkubb: this make sure that the PropertySet always contains remote keys
+descendants = DataMapper::Model.descendants.to_a
+while model = descendants.shift
+  descendants.concat(model.descendants.to_a - [ model ])
+  model.send(:assert_valid)
+end

data/lib/dm-cutie-ui/server.rb

@@ -0,0 +1,222 @@
+require 'sinatra/base'
+require 'erb'
+
+module DmCutieUI
+  class Server < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+    set :sessions,  true
+    set :static,    true
+    set :public,    dir / "server" / "public"
+    set :views,     DmCutieUI.view_root / 'views'
+        
+    # BEGIN ROUTES
+    get('/help') { erb :'default/help' }
+
+    get '/' do  
+      session["history"].each do |repo_key|
+        # Remove the key from the cookie, it was from a previous server boot
+        session["history"].delete(repo_key) if DmCutieUI.repos[repo_key].blank?
+      end if session["history"]
+
+      session.delete('current') if params['disconnect']
+
+      if !DmCutieUI.repos[session["current"]].blank?
+        erb :'default/index'
+      else
+        erb :'default/login'
+      end
+    end
+
+    post '/' do
+      begin
+        # This will be used by the repo method to get access to the repo the user selected
+        repo_key = DmCutieUI.connect params[:connection] 
+
+        if repo_key
+          session["history"] ||= []
+
+          session["history"] << repo_key unless session["history"].member?(repo_key)
+          session["current"] = repo_key.to_sym
+          erb :'default/index'
+        else
+          @connection_error = "That repository is missing some dm-cutie storages (#{DataMapper::Cutie.missing_storage.join(', ')})"
+          erb :'default/login'
+        end
+      rescue Exception => ex
+        # DataObjects::SyntaxError, LoadError
+        @connection_error = ex.message
+        erb :'default/login'    
+      end
+    end
+
+
+    ###################### GENERATE ROUTES ####################
+    # Generate routes for all files in 'sinatra/views/cutie_models'
+    # TODO: Create routes for --include-hooks once its supported
+    DataMapper::Cutie::MODELS.each do |model|
+      view_name  = model.to_s.pluralize
+      view_path  = DmCutieUI.view_root / 'views' / 'cutie_models' / "#{view_name}.erb"
+      view_uri   = "/#{view_name}"
+      if File.exist? view_path    
+        DmCutieUI.routes[view_uri] = {
+          :model      => model,
+          :file       => view_path,
+          :view_name  => view_name
+        }
+
+        # Create the 'controller'
+        get view_uri do
+          if !DmCutieUI.repos[session["current"]].blank?
+            # The cutie model being viewed
+
+            @view_name    = DmCutieUI.routes[ request.path_info ][:view_name]
+            @cutie_model  = DataMapper::Cutie.get_klass DmCutieUI.routes[ request.path_info ][:model]
+
+            @title        = DmCutieUI.routes[ request.path_info ][:model]
+
+            # Keep the response scoped to the users selected Cutie Repo
+            user_current_repo { erb(:"cutie_models/#{@view_name}") }        
+          else
+            @connection_error = "Select a DM repository to connect to"
+            redirect '/'
+          end
+        end
+
+      elsif !@model.blank?
+        puts "A view was not found for: #{@model}. This is probably an anonymous resource."
+      end # else probably an anonymous resource
+    end
+    
+    # END ROUTES
+    
+    # BEGIN HELPERS
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      ################
+      #  DM Cutie UI doesn't need your applications models 
+      #   she knows what she needs to know about them through
+      #   what DM Cutie stored in her tables
+      #   TODO - Remove the  need for uniq by grouping these, also consider a smart way to cache them per user
+      ################
+
+      # Gets a list of repo names from the Cutie Repo  
+      def repository_names
+        user_current_repo do
+          RepositoryStorage.all().map{ |rs| rs.repo_name }.uniq
+        end
+      end
+
+      # Gets a list of model names from the Cutie Repo  
+      def model_names
+        user_current_repo do
+          RepositoryStorage.all().map{ |rs| rs.model_name }.uniq
+        end
+      end
+
+      # Gets a list of adapter names from the Cutie Repo
+      def adapter_names
+        user_current_repo do
+          RepositoryStorage.all().map{ |rs| rs.adapter_name }.uniq
+        end
+      end
+
+      # Get the users chosen repository context
+      def user_current_repo
+        repository( session["current"] ) { yield }
+      end
+
+      def partial(template, *args)
+        template = File.join('shared',"_#{template}").to_sym
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options.merge!(:layout => false)
+
+
+        if collection = options.delete(:collection) then
+          collection.inject([]) do |buffer, member|
+            buffer << erb(template, options.merge(
+                                      :layout => false, 
+                                      :locals => {template.to_sym => member}
+                                    )
+                         )
+          end.join("\n")
+        else
+          erb(template, options)
+        end
+      end
+
+      # Parses the params hash looking for params that are properties of the model
+      #
+      def parse_params(model)
+        params.only *model.properties.map{|p| p.name.to_s} # Have to string this since sinatra params isnt a mash
+      end
+
+      def link_to(text,href)
+        %Q{<a href="#{href}">#{text}</a>}
+      end
+
+      # ram_filters - Filters for repository, adapter, and model
+      #
+      # An access for params[*_filter] 
+      #   Should be passed to determine the records to pass to display (Default provided: _grid partial)
+      def ram_filters
+        {
+          :repository => params['repository_filter'],
+          :adapter    => params['adapter_filter'],
+          :model      => params['model_filter']
+        }
+      end
+
+      # This is just a helper to get the property name or return the symbol if multiple data types are passed to
+      #   the 'grid' partials :columns attribute
+      #
+      # @param col [DataMapper::Property|Symbol]
+      # @returns [Symbol]
+      #
+      def column_name(col)
+        if col.is_a?(Symbol)
+          return col
+        else
+          return col.name.to_sym
+        end
+      end
+
+      # Adds a help link to the top of the page
+      def help_link
+        @help_link = %q{<a href="#help" class="help_link">help</a>}
+      end
+
+      # Creates a hyperlink to a filtered related model
+      #
+      def relationship_link(relationship, record)
+        relationship_name      = relationship.name
+
+        # This isnt going to work if multipart keys are ever used because its just doing parent_key.first
+        if relationship.parent_model == @cutie_model
+          filter_value      = record.send relationship.parent_key.first.name
+          remote_model_key  = relationship.child_key.first.name
+          remote_model      = relationship.child_model
+        else #its the child model
+          filter_value      = record.send relationship.child_key.first.name
+          remote_model_key  = relationship.parent_key.first.name 
+          remote_model      = relationship.parent_model
+        end
+
+        remote_model_name     = DataMapper::Cutie.get_human_name(remote_model).to_s.pluralize  
+        total_remote_records  = remote_model.all( remote_model_key => filter_value ).count
+        link_to "View: #{total_remote_records}", "/#{remote_model_name}?#{remote_model_key}=#{filter_value}"
+      end
+
+      # Returns 'selected="selected"' to reselect filter drop downs
+      def apply_selected_attribute(filter_name, filter_value)
+        if ram_filters[filter_name] == filter_value
+          'selected="SELECTED"'
+        end
+      end
+    end
+    
+    # END HELPERS
+    
+  end
+end