astroboa-cli 0.3.0

data/lib/astroboa-cli/cli.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require "astroboa-cli/command"
+
+module AstroboaCLI
+  
+  class CLI
+    def self.start(*args)
+        command = args.shift.strip rescue "help"
+        AstroboaCLI::Command.load
+        AstroboaCLI::Command.run(command, args)
+      end
+    
+  end
+  
+end

data/lib/astroboa-cli/command/base.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+
+# This file contains modifications of work covered by the following copyright and  
+# permission notice:
+#
+# The MIT License (MIT)
+# 
+# Copyright © Heroku 2008 - 2012
+# 
+# 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.
+
+
+require 'logger'
+
+module AstroboaCLI::Command
+  
+  class Base
+    include AstroboaCLI::Util
+    
+    def self.namespace
+      self.to_s.split("::").last.downcase
+    end
+    
+    attr_reader :args
+    attr_reader :options
+    attr_reader :log
+    attr_reader :log_file
+
+    def initialize(args=[], options={})
+      @args = args
+      @options = options
+      
+      @log_file = '/tmp/astroboa-cli-log.txt'
+      @log = Logger.new(@log_file)
+      @log.level = Logger::INFO
+      
+      # Check if the proper version of ruby is running
+      ruby_ok?
+    end
+    
+  protected
+    def self.inherited(klass)
+      return if klass == AstroboaCLI::Command::Base
+      
+      help = extract_help_from_caller(caller.first)
+
+      AstroboaCLI::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.split("\n").first,
+        :long_description => help.split("\n")
+      )
+    end
+  
+    def self.method_added(method)
+      return if self == AstroboaCLI::Command::Base
+      return if private_method_defined?(method)
+      return if protected_method_defined?(method)
+
+      help = extract_help_from_caller(caller.first)
+      
+      resolved_method = (method.to_s == "default") ? nil : method.to_s
+      command = [ self.namespace, resolved_method ].compact.join(":")
+      banner = extract_banner(help) || command
+      permute = !banner.index("*")
+      banner.gsub!("*", "")
+
+      AstroboaCLI::Command.register_command(
+        :klass       => self,
+        :method      => method,
+        :namespace   => self.namespace,
+        :command     => command,
+        :banner      => banner,
+        :help        => help,
+        :summary     => extract_summary(help),
+        :description => extract_description(help),
+        :options     => extract_options(help),
+        :permute     => permute
+      )
+    end
+    
+    # Parse the caller format and identify the file and line number as identified
+    # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
+    # look for a colon followed by a digit as the delimiter.  The biggest
+    # complication is windows paths, which have a color after the drive letter.
+    # This regex will match paths as anything from the beginning to a colon
+    # directly followed by a number (the line number).
+    #
+    # Examples of the caller format :
+    # * c:/Ruby192/lib/.../lib/astroboa-cli/command/server.rb:8:in `<module:Command>'
+    #
+    def self.extract_help_from_caller(line)
+      # pull out of the caller the information for the file path and line number
+      if line =~ /^(.+?):(\d+)/
+        return extract_help($1, $2)
+      end
+      raise "unable to extract help from caller: #{line}"
+    end
+
+    def self.extract_help(file, line)
+      buffer = []
+      lines  = File.read(file).split("\n")
+
+      catch(:done) do
+        (line.to_i-2).downto(0) do |i|
+          case lines[i].strip[0..0]
+            when "", "#" then buffer << lines[i]
+            else throw(:done)
+          end
+        end
+      end
+
+      buffer.map! do |line|
+        line.strip.gsub(/^#/, "")
+      end
+
+      buffer.reverse.join("\n").strip
+    end
+
+    def self.extract_banner(help)
+      help.split("\n").first
+    end
+
+    def self.extract_summary(help)
+      extract_description(help).split("\n").first
+    end
+
+    def self.extract_description(help)
+      lines = help.split("\n").map { |l| l.strip }
+      lines.shift
+      lines.reject do |line|
+        line =~ /^-(.+)#(.+)/
+      end.join("\n").strip
+    end
+
+    def self.extract_options(help)
+      help.split("\n").map { |l| l.strip }.select do |line|
+        line =~ /^-(.+)#(.+)/
+      end.inject({}) do |hash, line|
+        description = line.split("#", 2).last.strip
+        long  = line.match(/--([A-Za-z_\- ]+)/)[1].strip
+        short = line.match(/-([A-Za-z ])/)[1].strip
+        hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
+      end
+    end
+
+    def extract_option(name, default=true)
+      key = name.gsub("--", "").to_sym
+      return unless options[key]
+      value = options[key] || default
+      block_given? ? yield(value) : value
+    end
+
+  
+  end # class base
+    
+end # Module AstroboaCLI::Command

data/lib/astroboa-cli/command/help.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require "astroboa-cli/command/base"
+  
+# display available commands and help
+#
+class AstroboaCLI::Command::Help < AstroboaCLI::Command::Base
+  
+  # help [COMMAND]
+  #
+  # list available commands or display help for a specific command
+  #
+  def default
+    if command = args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+  
+private
+  
+  def subcommands_in_namespace(name)
+    AstroboaCLI::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+    
+  def help_for_root
+    puts "Usage: astroboa-cli COMMAND [command-specific-options]"
+    puts
+    puts "To get help about a top command, type \"astroboa-cli help command\""
+    puts "Available top commands:"
+    summary_for_namespaces
+    puts
+  end
+  
+  def summary_for_namespaces
+    size = longest(AstroboaCLI::Command.namespaces.values.map { |namespace| namespace[:name] })
+    AstroboaCLI::Command.namespaces.values.sort_by {|namespace| namespace[:name]}.each do |namespace|
+      name = namespace[:name]
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+  
+  def help_for_subcommands_in_namespace(namespace)
+    subcommands = subcommands_in_namespace(namespace)
+
+    unless subcommands.empty?
+      size = longest(subcommands.map { |c| c[:banner] })
+      subcommands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if command[:help] =~ /DEPRECATED/
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+  
+  def help_for_command(name)
+    puts AstroboaCLI::Command.namespaces[name][:long_description] if AstroboaCLI::Command.namespaces[name]
+    puts
+    command = AstroboaCLI::Command.commands[name]
+    
+    if command
+      puts "Usage: astroboa-cli #{command[:banner]}"
+
+      if command[:help].strip.length > 0
+        command[:help].split("\n")[1..-1].each do |line|
+          if line =~ /#/
+            option_parts = line.split('#')
+            puts "#{option_parts[0]}"
+            option_parts[1..-1].each do |sentence|
+              puts "\t #{sentence}"
+            end
+            puts
+          elsif
+            puts line
+          end
+        end
+        
+        puts
+      end
+    end
+    
+    # if there are sub commands inform the user
+    if subcommands_in_namespace(name).size > 0
+      puts "This top command supports the following sub-commands, type \"astroboa-cli help SUB-COMMAND\" to get help:"
+      puts
+      help_for_subcommands_in_namespace(name)
+      puts
+    elsif command.nil? # if there are not subcommands and the top command itself does not exist display an error
+      error "#{name} is not an astroboa command. See 'astroboa-cli help'."
+    end
+  end
+  
+end

data/lib/astroboa-cli/command/model.rb

@@ -0,0 +1,181 @@
+# encoding: UTF-8
+
+require 'nokogiri'
+require 'fileutils'
+  
+# Manage your domain models
+#
+# Astroboa facilitates a DOMAIN DRIVEN design of applications.
+# The core of your application(s) is the DOMAIN MODEL, a graph of ENTITIES that describe 
+# the type of information your application(s) will create, consume and search.
+#
+# In order to store your application(s) data you follow three simple steps:
+# 1) you create an astroboa repository (astroboa-cli repository:create)
+# 2) you create your domain model by:
+#   - using the Astroboa Entity Definition DSL which is very close to ActiveRecord::Schema definitions of ruby on rails
+#   - directy writing an XML Schema for each entity (or a single schema to include all entity definitions)
+# 3) you "associate" your domain model with the repository you just created (astroboa-cli model:associate)
+#
+# One of the best features of astroboa is its programming-language agnostic and dynamic domain model that can be shared between applications. 
+# You do not need to create model classes for your applications. Astroboa uses the domain model that you define once and
+# dynamically creates the appropriate objects for your app. 
+# Additionally you can "model-as-you-go", that is you may define new entities 
+# or update existing ones at any time during development or production.
+# Astroboa will automatically update the APIs and the generated object instances to the updated domain model.
+#
+class AstroboaCLI::Command::Model < AstroboaCLI::Command::Base
+  
+  # model:associate REPOSITORY MODEL_DIR
+  #
+  # This command allows you to associate a repository with a domain model.
+  # After the association is done your repository can store entities that follow the domain model.
+  #
+  # It is recommended to use this command only on new repositories because it does not cope with model updates 
+  # (it will cause instant performace decrease because it resets the whole repository schema and most important 
+  # it may render your data inaccessible if the updated model contain changes to property names or property value cardinality) 
+  # If you change a domain model that has been already associated with a repository use 'astroboa-cli model:propagate_updates'   
+  #
+  # If you specify the 'MODEL_DIR' (i.e. where your models are stored) then your DSL model definition is expected to be 
+  # in 'MODEL_DIR/dsl' and your XML Schemas to be in 'MODEL_DIR/xsd' 
+  # If you do not specify the 'MODEL_DIR' then domain model is expected to be found inside current directory in 'model/dsl' and 'model/xsd'
+  #
+  def associate
+    
+    if repository = args.shift
+      repository = repository.strip
+    else
+      error "Please specify the repository name. Usage: model:associate REPOSITORY MODEL_DIR"
+    end
+    
+    server_configuration = get_server_configuration
+    
+    error "Repository '#{repository}' does not exist or it is not properly configured (use astroboa-cli repository:list to see available repositories)" unless repository?(server_configuration, repository)
+    
+    if model_dir = args.shift
+      model_dir = model_dir.strip
+    else
+      model_dir = File.join(Dir.getwd, 'model')
+    end
+    
+    error <<-MSG unless Dir.exists? model_dir
+    Directory #{model_dir} does not exist. 
+    If you specify the 'MODEL_DIR' then your DSL model definition is expected to be 
+    in 'MODEL_DIR/dsl' and your XML Schemas to be in 'MODEL_DIR/xsd' 
+    If you do not specify the 'MODEL_DIR' then domain model is expected to be found inside current directory in 'model/dsl' and 'model/xsd'
+    MSG
+    
+    astroboa_dir = server_configuration['install_dir']
+    
+    display "Looking for XML Schemas..."
+    xsd_dir = File.join model_dir, 'xsd'
+    model_contains_xsd = Dir.exists?(xsd_dir) && Dir.entries(xsd_dir) != [".", ".."]
+    
+    if model_contains_xsd
+      display "Found XML Schemas in '#{xsd_dir}'"
+      display "Validating XML Schemas..."
+      
+      tmp_dir = File.join(astroboa_dir, 'tmp')
+      
+      FileUtils.rm_r tmp_dir if Dir.exists? tmp_dir
+      
+      FileUtils.mkdir_p tmp_dir
+      FileUtils.cp_r File.join(astroboa_dir, 'schemas'), tmp_dir
+      
+      tmp_schema_dir = File.join(tmp_dir, 'schemas')
+      FileUtils.cp_r Dir.glob(File.join(xsd_dir, '*.xsd')), tmp_schema_dir
+      
+      # Validate schemas in domain model
+      Dir[File.join(xsd_dir, '*.xsd')].each  do |schema_path|
+        schema_file = schema_path.split('/').last
+        
+        display
+        display '-------------------------------------------------'
+        display "Validating XML Schema: #{schema_file}"
+        error "Please correct the schema file '#{schema_file}' and run the command again" unless domain_model_valid? schema_file, tmp_schema_dir
+      end
+      
+      # copy schemas to repository schemas directory
+      repository_schema_dir = File.join(server_configuration['repos_dir'], repository, 'astroboa_schemata')
+      FileUtils.cp_r Dir.glob(File.join(xsd_dir, '*.xsd')), repository_schema_dir
+      
+      display
+      display '-------------------------------------------------'
+      display '-------------------------------------------------'
+      display "Repository '#{repository}' associated to XML Schemas in '#{xsd_dir}': OK"
+    else
+      display "No XML Schemas Found"
+    end
+    
+    
+  end
+  
+  # model:graph DOMAIN_MODEL
+  #
+  # Draws a graphic representation of the domain model
+  def graph
+    
+  end
+  
+  # model:view PATH
+  #
+  # Displays the model of an entity or entity property
+  def view
+    
+  end
+  
+  # model:list DOMAIN_MODEL
+  #
+  # Displays information about the domain models and their entities
+  def list
+    
+  end
+  
+private
+
+  def domain_model_valid? domain_model_file, schemas_dir
+    Dir.chdir(schemas_dir) do
+
+      # first make sure that Domain model is a well formed XML Doc and if not show errors
+      domain_model_doc = Nokogiri::XML(File.read(domain_model_file))
+      unless domain_model_doc.errors.empty?
+        puts "#{domain_model_file} is not a well formed XML Document"
+        puts domain_model_doc.errors
+        return false
+      else
+        puts "Check if domain model is a well formed XML Document: OK"
+      end
+      
+      # Then check if domain model is a valid XML Schema, i.e. validate it against the XML Schema schema 
+      xml_schema_grammar = File.read('XMLSchema.xsd')
+      xml_schema_validator = Nokogiri::XML::Schema(xml_schema_grammar)
+
+      errors = xml_schema_validator.validate(domain_model_doc)
+      
+      unless errors.empty?
+        puts "Check if domain model is a valid XML Schema: Not valid XML Schema"
+        errors.each do |error|
+          puts error.message
+        end
+        return false
+      else
+        puts  "Check if domain model is a valid XML Schema: OK"
+      end
+
+      # Finally check if domain model is valid against its dependencies to astroboa schemas and external user-provided schemas, 
+      # i.e. it properly loads and uses all its external schema dependencies
+      begin
+        external_schemas_validator = Nokogiri::XML::Schema(File.read(domain_model_file))
+        puts 'Check if domain model properly loads and uses external schemas (i.e. astroboa model schemas + user defined schemas): OK'
+        true
+      rescue Exception => e
+        puts 'Check if domain model is properly loading and using external schemas (i.e. astroboa model schemas + user defined schemas): Errors found!'
+        puts external_schemas_validator.errors if external_schemas_validator
+        puts e.message
+        false
+      end
+
+    end
+
+  end
+
+end