coral_core 0.1.2

data/README.rdoc

@@ -0,0 +1,33 @@
+= coral_core
+
+This library provides core data elements and utilities used in other Coral gems.
+
+The Coral core library contains functionality that is utilized by other
+Coral gems by providing basic utilities like Git, Shell, Disk, and Data
+manipulation libraries, a UI system, and a core data model that supports
+Events, Commands, Repositories, and Memory (version controlled JSON 
+objects).  This library is only used as a starting point for other systems.
+
+Note:  This library is still very early in development!
+
+== Contributing to coral_core
+ 
+* Check out the latest master to make sure the feature hasn't been implemented 
+  or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested 
+  it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a 
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want 
+  to have your own version, or is otherwise necessary, that is fine, but 
+  please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Licensed under GPLv3.  See LICENSE.txt for further details.
+
+Copyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>
+Coral Technology Group LLC

data/Rakefile

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+require 'bundler'
+require 'jeweler'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+require 'yard'
+
+require './lib/coral_core.rb'
+
+#-------------------------------------------------------------------------------
+# Dependencies
+
+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
+
+#-------------------------------------------------------------------------------
+# Gem specification
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name                  = "coral_core"
+  gem.homepage              = "http://github.com/coraltech/ruby-coral_core"
+  gem.rubyforge_project     = 'coral_core'
+  gem.license               = "GPLv3"
+  gem.email                 = "adrian.webb@coraltech.net"
+  gem.authors               = ["Adrian Webb"]
+  gem.summary               = %Q{Provides core data elements and utilities used in other Coral gems}
+  gem.description           = File.read('README.rdoc')  
+  gem.required_ruby_version = '>= 1.8.1'
+  gem.has_rdoc              = true
+  gem.rdoc_options << '--title' << 'Coral Core library' <<
+                      '--main' << 'README.rdoc' <<
+                      '--line-numbers' 
+  
+  # Dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+#-------------------------------------------------------------------------------
+# Testing
+
+RSpec::Core::RakeTask.new(:spec, :tag) do |spec, task_args|
+  options = []
+  options << "--tag #{task_args[:tag]}" if task_args.is_a?(Array) && ! task_args[:tag].to_s.empty?  
+  spec.rspec_opts = options.join(' ')
+end
+
+task :default => :spec
+
+#-------------------------------------------------------------------------------
+# Documentation
+
+version   = Coral::VERSION
+doc_title = "coral_core #{version}"
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = doc_title
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+#---
+
+YARD::Rake::YardocTask.new do |ydoc|
+  ydoc.files   = [ 'README*', 'lib/**/*.rb' ]
+  ydoc.options = [ "--output-dir yardoc", "--title '#{doc_title}'" ]
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/coral_core/command.rb

@@ -0,0 +1,236 @@
+
+module Coral
+class Command < Core
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  attr_accessor :name
+  attr_reader :subcommand
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def initialize(options = {})
+  
+    if options.is_a?(String) || options.is_a?(Symbol)
+      options = string(options)
+      options = { :name => options, :command => options }
+    end
+  
+    super(options)
+    
+    @properties           = {}
+    
+    self.subcommand       = options[:subcommand] if options.has_key?(:subcommand)
+    
+    @name                 = ( options.has_key?(:name) ? string(options[:name]) : '' )
+    
+    @properties           = options
+    @properties[:command] = executable(options)   
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+ 
+  def command_base
+    return @properties[:command]
+  end
+  
+  #---
+  
+  def command=command
+    @properties[:command] = executable({ :command => command })
+  end
+  
+  #---
+  
+  def vagrant=command
+    @properties[:command] = executable({ :vagrant => command })
+  end
+  
+  #---
+  
+  def coral=command
+    @properties[:command] = executable({ :coral => command })
+  end
+  
+  #---
+  
+  def args
+    return array(@properties[:args]) 
+  end
+  
+  #---
+  
+  def args=args
+    @properties[:args] = array(args)
+  end
+  
+  #---
+  
+  def flags
+    return array(@properties[:flags]) 
+  end
+  
+  #---
+  
+  def flags=flags
+    @properties[:flags] = array(flags)
+  end
+  
+  #---
+  
+  def data
+    return hash(@properties[:data]) 
+  end
+  
+  #---
+  
+  def data=data
+    @properties[:data] = hash(data)
+  end
+  
+  #---
+  
+  def subcommand=subcommand
+    @properties[:subcommand] = hash(subcommand)
+    @subcommand = Module.const_get("Coral").const_get(self.class).new(@properties[:subcommand])
+  end
+
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return symbol_map(@properties)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Command functions
+  
+  def build(components = {}, overrides = nil, override_key = false)    
+    
+    command            = string(components[:command])
+    flags              = array( components.has_key?(:flags) ? components[:flags] : [] )
+    data               = string_map(hash( components.has_key?(:data) ? components[:data] : {} ))
+    args               = array( components.has_key?(:args) ? components[:args] : [] )
+    subcommand         = hash( components.has_key?(:subcommand) ? components[:subcommand] : {} )
+    
+    override_key       = command unless override_key
+    override_key       = override_key.to_sym
+    
+    command_string     = command.dup
+    subcommand_string  = ''
+    
+    escape_characters  = /[\'\"]+/
+    escape_replacement = '\"'
+    
+    dash_pattern       = /^([\-]+)/
+    assignment_pattern = /\=$/
+    
+    # Flags
+    if overrides && overrides.has_key?(:flags)
+      if overrides[:flags].is_a?(Hash)
+        if overrides[:flags].has_key?(override_key)
+          flags = array(overrides[:flags][override_key])
+        end
+      else
+        flags = array(overrides[:flags])
+      end
+    end
+    flags.each do |flag|
+      if flag && ! flag.empty?
+        flag = string(flag)
+        
+        if flag.match(dash_pattern)
+          dashes = $1
+        else
+          dashes = ( flag.size == 1 ? '-' : '--' )  
+        end
+        command_string << " #{dashes}#{flag}"
+      end
+    end
+    
+    # Data
+    if overrides && overrides.has_key?(:data)
+      if overrides[:data].has_key?(override_key)
+        data = hash(overrides[:data][override_key])
+      else
+        override = true
+        overrides[:data].each do |key, value|
+          if ! value.is_a?(String)
+            override = false
+          end
+        end
+        data = hash(overrides[:data]) if override
+      end
+    end
+    data.each do |key, value|
+      key   = string(key)
+      value = string(value).strip.sub(escape_characters, escape_replacement)
+      
+      if key.match(dash_pattern)
+        dashes = $1
+      else
+        dashes = ( key.size == 1 ? '-' : '--' )  
+      end      
+      space = ( key.match(assignment_pattern) ? '' : ' ' )  
+      
+      command_string << " #{dashes}#{key}#{space}'#{value}'"
+    end
+    
+    # Arguments
+    if overrides && overrides.has_key?(:args)
+      if overrides[:args].is_a?(Hash)
+        if overrides[:args].has_key?(override_key)
+          args = array(overrides[:args][override_key])
+        end
+      else
+        args = array(overrides[:args])
+      end
+    end
+    args.each do |arg|
+      arg = string(arg).sub(escape_characters, escape_replacement)
+      command_string << " '#{arg}'"
+    end
+    
+    # Subcommand
+    subcommand_overrides = ( overrides ? overrides[:subcommand] : nil )
+    if subcommand && subcommand.is_a?(Hash) && ! subcommand.empty?
+      subcommand_string = build(subcommand, subcommand_overrides)
+    end
+    
+    return (command_string + ' ' + subcommand_string).strip
+  end
+  
+  #-----------------------------------------------------------------------------
+    
+  def exec!(options = {}, overrides = nil)
+    success = Coral::Util::Shell.exec!(build(export, overrides), options) do |line|
+      block_given? ? yield(line) : true
+    end    
+    return success
+  end
+  
+  #---
+  
+  def exec(options = {}, overrides = nil)
+    return exec!(options, overrides)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def executable(options)
+    if options.has_key?(:coral)
+      return 'vagrant coral ' + options[:coral]
+        
+    elsif options.has_key?(:vagrant)
+      return 'vagrant ' + options[:vagrant]
+        
+    elsif options.has_key?(:command)
+      return options[:command]
+    end
+  end
+end
+end

data/lib/coral_core/core.rb

@@ -0,0 +1,200 @@
+
+module Coral
+class Core
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    @ui = Coral::Interface.new(options)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessor / Modifiers
+  
+  attr_accessor :ui
+  
+  #-----------------------------------------------------------------------------
+  
+  def self.logger
+    return @ui.class.logger
+  end
+  
+  #--- 
+   
+  def logger
+    return @ui.logger
+  end
+  
+  #---
+ 
+  def logger=logger
+    @ui.logger = logger
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # General utilities
+
+  def self.symbol_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_sym] = symbol_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def symbol_map(data)
+    return self.class.symbol_map(data)
+  end
+  
+  #---
+  
+  def self.string_map(data)
+    results = {}
+    return data unless data
+    
+    case data
+    when Hash
+      data.each do |key, value|
+        results[key.to_s] = string_map(value)
+      end
+    else
+      results = data
+    end    
+    return results
+  end
+  
+  #---
+  
+  def string_map(data)
+    return self.class.string_map(data)
+  end
+  
+  #-----------------------------------------------------------------------------
+      
+  def self.filter(data, method = false)
+    if method && method.is_a?(Symbol) && 
+      [ :array, :hash, :string, :symbol, :test ].include?(method.to_sym)
+      return send(method, data)
+    end
+    return data
+  end
+  
+  #---
+  
+  def filter(data, method = false)
+    return self.class.filter(data, method)
+  end
+    
+  #-----------------------------------------------------------------------------
+          
+  def self.array(data, default = [], split_string = false)
+    result = default    
+    if data && ! data.empty?
+      case data
+      when Array
+        result = data
+      when String
+        result = [ ( split_string ? data.split(/\s*,\s*/) : data ) ]
+      else
+        result = [ data ]
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def array(data, default = [], split_string = false)
+    return self.class.array(data, default, split_string)
+  end
+    
+  #---
+        
+  def self.hash(data, default = {})
+    result = default    
+    if data && ! data.empty?
+      case data
+      when Hash
+        result = data
+      else
+        result = {}
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def hash(data, default = {})
+    return self.class.hash(data, default)
+  end
+    
+  #---
+         
+  def self.string(data, default = '')
+    result = default    
+    if data && ! data.empty?
+      case data
+      when String
+        result = data
+      else
+        result = data.to_s
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def string(data, default = '')
+    return self.class.string(data, default)
+  end
+    
+  #---
+         
+  def self.symbol(data, default = :undefined)
+    result = default    
+    if data && ! data.empty?
+      case data
+      when Symbol
+        result = data
+      when String
+        result = data.to_sym
+      else
+        result = data.class.to_sym
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def symbol(data, default = '')
+    return self.class.symbol(data, default)
+  end
+     
+  #---
+    
+  def self.test(data)
+    return false if ! data || data.empty?      
+    return false if data.is_a?(String) && data =~ /^(FALSE|false|False|No|no|N|n)$/      
+    return true
+  end
+  
+  #---
+  
+  def test(data)
+    return self.class.test(data)
+  end  
+end
+end

data/lib/coral_core/event/regexp_event.rb

@@ -0,0 +1,55 @@
+
+module Coral
+class RegexpEvent < Event
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  TYPE = :regexp
+
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    options[:type] = TYPE
+    
+    super(options)
+    
+    if options.has_key?(:string)
+      self.pattern = options[:string]
+    end
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def pattern
+    return property(:pattern, '', :string)
+  end
+  
+  #---
+   
+  def pattern=pattern
+    set_property(:pattern, string(pattern))  
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return "#{type}:#{pattern}"
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Event handling
+  
+  def check(source)
+    if source.match(/#{pattern}/)
+      logger.debug("MATCH! -> #{pattern} matched #{source}") 
+      return true                  
+    end
+    logger.debug("nothing -> #{pattern} - #{source}")
+    return false
+  end
+end
+end