Lidia 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+rdoc
+pkg

data/History.txt

@@ -0,0 +1,13 @@
+=== 0.0.2 2010-12-30
+
+* 1 major enhancement:
+  * moved to gitorious
+  * uploaded to rubygems
+
+=== 0.0.1 2010-12-28
+
+* 1 major enhancement:
+  * work on dar definition 60%
+  * work on gpg definition  5%
+  * work on ls definition   5%
+  * some tests

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lidia.gemspec
+lib/lidia.rb
+lib/lidia/command.rb
+lib/lidia/parameter.rb
+lib/lidia/source.rb
+script/console
+script/destroy
+script/generate
+spec/lidia/command_spec.rb
+sources/ls.lidia.yml
+sources/gpg.lidia.yml
+sources/dar.lidia.yml
+
+
+

data/PostInstall.txt

@@ -0,0 +1,5 @@
+
+For more information on lidia, see http://lidia.rubyforge.org
+
+
+

data/README.rdoc

@@ -0,0 +1,134 @@
+= LIDIA
+
+* http://gitorious/gnoxys/lidia
+
+== DESCRIPTION:
+
+Lidia is a yml based command contructor class. Aims to be easy to use and to provide an easy way to remember tons of commands
+
+== SYNOPSIS:
+
+Lidia's is written to provide an easy way to manage commands calls. Commands structure can be defined in an easy yaml file.
+
+  # $your editor ls.lidia.yml
+  : ==parameters:
+    :columns:
+      :option: -l
+      :description:  listing format@
+
+By default, lidia loads definition files from gem installation folder ../source, or you can pass with <tt>:definition_file</tt> the location
+
+  >> Lidia::Command.new('ls', {}, :definition_file => 'ls.lidia.yml')
+  => Lidia::Command 
+        + name: ls,
+        + definition file at:/var/www/lidia/sources/ls.lidia.yml
+        + parameters:
+          * name: columns               group: option    , value: nil
+
+Values can be passed as argument on new, or creating by block
+
+  >> Lidia::Command.new('ls', {:columns => true })
+  ?> Lidia::Command.new('ls') do |l|
+  ?>   l.columns = true
+  >> end
+  => Lidia::Command 
+        + name: ls,
+        + definition file at:/var/www/lidia/sources/ls.lidia.yml
+        + parameters:
+          * name: columns               group: option    , value: true 
+
+Once u have defined all the parameters that your command will use, define which actions can be done, por example, list_by_columns
+
+  # your editor ls.lidia.yml
+  # :actions:
+  #   :list_by_columns:
+  #     :parameters:
+  #       :required: [ :columns ]
+
+Now ask for <tt>command_for</tt> lidia list_by_columns
+
+  >> l = Lidia::Command.new('ls', {:columns => nil })
+  => Lidia::Command 
+        + name: ls,
+        + definition file at:/var/www/lidia/sources/ls.lidia.yml
+        + parameters:
+          * name: columns               group: option    , value: nil 
+        
+  >> l.command_for(:list_by_columns)
+  ArgumentError: Parameter columns required but not valid
+
+Ooops, parameter -l is required, to list_by_columns action, so set it to true
+
+  >> l.columns = true
+  => true
+  >> l.command_for(:list_by_columns)
+  => "/bin/ls -l"
+
+We want sometimes, list other directory. so prepare defintion file to get an argument
+
+  # $your editor ls.lidia.yml
+  # :parameters:
+  #   :list_what:
+  #     :description:  what do u want to list?
+
+this option can be used for listing_by_columns to, but it is not mandatary
+
+  # $your editor ls.lidia.yml
+  # :actions:
+  #   :list_by_columns:
+  #     :parameters:
+  #       :required: [ :columns ]
+  #       :optional: [ :list_what ]
+
+Now, no exceptions is raised, but argument can be used
+
+  >> l = Lidia::Command.new('ls', {:columns => true })
+  => Lidia::Command 
+        + name: ls,
+        + definition file at:/var/www/lidia/sources/ls.lidia.yml
+        + parameters:
+          * name: columns               group: option    , value: true 
+          * name: list_what             group: argument  , value: nil 
+        
+  >> l.command_for(:list_by_columns)
+  => "/bin/ls -l "
+  >> l.list_what = '/tmp'
+  => "/tmp"
+  >> l.command_for(:list_by_columns)
+  => "/bin/ls -l   \"/tmp\" "
+
+
+
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIXME full name
+
+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/Rakefile

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+require 'rake'
+require 'rake/rdoctask'
+require 'rubygems'
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'bundler'
+require File.join(File.dirname(__FILE__), 'lib', 'lidia')
+
+
+Rspec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["--color"]
+end
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Lidia'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/lidia.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'lidia/command'
+require 'lidia/parameter'
+require 'lidia/source'
+
+module Lidia
+  VERSION = '0.0.2'
+end

data/lib/lidia/command.rb

@@ -0,0 +1,181 @@
+module Lidia #:nodoc:#
+  class Command
+
+    SYNTAX_REX = /\%([a-z_]*)\{([a-z_]*)\}/
+      
+    attr_reader :name
+    attr_reader :source
+    attr_reader :config
+    attr_reader :definition_file
+    attr_reader :path
+    attr_reader :options
+    
+    attr_accessor :parameters
+    attr_accessor :current_action_name
+    attr_accessor :current_action_config  
+    attr_accessor :current_action_cmd
+    
+    
+    # Lidia's is written to provide an easy way to manage commands calls. Commands structure can be defined in an easy yaml file.
+    # 
+    #   # $your editor ls.lidia.yml
+    #   :parameters:
+    #     :columns:
+    #       :option: -l
+    #       :description:  listing format
+    # 
+    # By default, lidia loads definition files from gem installation folder ../source, or you can pass with <tt>:definition_file</tt> the location
+    # 
+    #   >> Lidia::Command.new('ls', {}, :definition_file => 'ls.lidia.yml')
+    #   => Lidia::Command 
+    #         + name: ls,
+    #         + definition file at:/var/www/lidia/sources/ls.lidia.yml
+    #         + parameters:
+    #           * name: columns               group: option    , value: nil
+    # 
+    # Values can be passed as argument on new, or creating by block
+    # 
+    #   >> Lidia::Command.new('ls', {:columns => true })
+    #   ?> Lidia::Command.new('ls') do |l|
+    #   ?>   l.columns = true
+    #   >> end
+    #   => Lidia::Command 
+    #         + name: ls,
+    #         + definition file at:/var/www/lidia/sources/ls.lidia.yml
+    #         + parameters:
+    #           * name: columns               group: option    , value: true 
+    # 
+    # Once u have defined all the parameters that your command will use, define which actions can be done, por example, list_by_columns
+    # 
+    #   # your editor ls.lidia.yml
+    #   # :actions:
+    #   #   :list_by_columns:
+    #   #     :parameters:
+    #   #       :required: [ :columns ]
+    # 
+    # Now ask for <tt>command_for</tt> lidia list_by_columns
+    # 
+    #   >> l = Lidia::Command.new('ls', {:columns => nil })
+    #   => Lidia::Command 
+    #         + name: ls,
+    #         + definition file at:/var/www/lidia/sources/ls.lidia.yml
+    #         + parameters:
+    #           * name: columns               group: option    , value: nil 
+    #         
+    #   >> l.command_for(:list_by_columns)
+    #   ArgumentError: Parameter columns required but not valid
+    # 
+    # Ooops, parameter -l is required, to list_by_columns action, so set it to true
+    # 
+    #   >> l.columns = true
+    #   => true
+    #   >> l.command_for(:list_by_columns)
+    #   => "/bin/ls -l"
+    # 
+    # We want sometimes, list other directory. so prepare defintion file to get an argument
+    # 
+    #   # $your editor ls.lidia.yml
+    #   # :parameters:
+    #   #   :list_what:
+    #   #     :description:  what do u want to list?
+    # 
+    # this option can be used for listing_by_columns to, but it is not mandatary
+    # 
+    #   # $your editor ls.lidia.yml
+    #   # :actions:
+    #   #   :list_by_columns:
+    #   #     :parameters:
+    #   #       :required: [ :columns ]
+    #   #       :optional: [ :list_what ]
+    # 
+    # Now, no exceptions is raised, but argument can be used
+    # 
+    #   >> l = Lidia::Command.new('ls', {:columns => true })
+    #   => Lidia::Command 
+    #         + name: ls,
+    #         + definition file at:/var/www/lidia/sources/ls.lidia.yml
+    #         + parameters:
+    #           * name: columns               group: option    , value: true 
+    #           * name: list_what             group: argument  , value: nil 
+    #         
+    #   >> l.command_for(:list_by_columns)
+    #   => "/bin/ls -l "
+    #   >> l.list_what = '/tmp'
+    #   => "/tmp"
+    #   >> l.command_for(:list_by_columns)
+    #   => "/bin/ls -l   \"/tmp\" "
+    def initialize(command_name, parameters = {}, options = {})
+      @name         = command_name
+      @options      = options
+      
+      @source       = Lidia::Source.new({:include => (options[:definition_file] ? File.dirname(options[:definition_file]) : nil) })
+      @config       = load_config
+      @path         = @options[:path] || @config[:path] ||  %x[ which #{ command_name } ].strip
+      
+      @parameters   = Lidia::Parameter.build(self, parameters)
+      
+      @parameters.each do |parameter|
+        get_block = Proc.new{     self.get_parameter_value(parameter.name)    }
+        set_block = Proc.new{ |v| self.set_parameter_value(parameter.name, v) }       
+        
+        self.class.send(:define_method, "#{ parameter.name }",  get_block)
+        self.class.send(:define_method, "#{ parameter.name }=", set_block)
+      end
+      
+      yield self if block_given?
+    end
+    
+    def command_for(name)
+      build_action(name) ? @current_action_cmd : raise(ArgumentError, "not valid action #{ name }")
+    end
+    
+    def inspect
+      %(#{ self.class.name } 
+      + name: #{ @name },
+      + definition file at:#{ @definition_file }
+      + parameters:
+        #{ @parameters.sort{|a,b| a.name.to_s <=> b.name.to_s }.map(&:inspect).join("\n        ") }
+      )
+    end
+    
+    def get_parameter_value(parameter_name)
+      parameter = @parameters.select{ |p| p.name == parameter_name }.first
+      parameter ? parameter.value : raise(NoMethodError)
+    end
+    
+    def set_parameter_value(parameter_name, value)
+      parameter = @parameters.select{ |p| p.name == parameter_name }.first
+      parameter ? (parameter.value = value) : raise(NoMethodError)
+    end
+    
+    private
+    # Load definition file as execpted YAML file.
+    # FIXME more information to this method
+    def load_config
+      @definition_file = @source.find(@name)
+      YAML.load_file(@definition_file)      
+    end
+    
+    # Build action set variables to build command for an action.
+    # Return buildt command
+    def build_action(action)
+      @current_action_name   = action                    || raise(ArgumentError, "action is nil #{ action }")
+      @current_action_config = @config[:actions][action] || raise(ArgumentError, "no valid config for action #{ action }")
+      
+      validate_and_build_command
+    end
+    
+    def validate_and_build_command
+      valid_action? ? build_command : false 
+    end
+    
+    # Check if current_action_name and current_action_config are not nil and command can be built.
+    def valid_action?
+      !@current_action_name.nil? || !@current_action_config.nil?
+    end
+    
+    def build_command
+      @current_action_cmd = "#{ @path } #{ Lidia::Parameter.parameters_for_command_line(@parameters, @current_action_config[:parameters][:required]) }"
+    end
+  end
+end

data/lib/lidia/parameter.rb

@@ -0,0 +1,171 @@
+module Lidia #:nodoc:#
+  class Parameter
+    
+    COMMAND_LINE_SORT = [ 'option_required', 'option', 'argument_required', 'argument' ]
+    
+    attr_reader :command
+    attr_reader :name
+    attr_reader :required_argument
+    attr_reader :group
+    attr_reader :prefix
+    
+    
+    attr_accessor :required_by_action
+    attr_accessor :value
+    
+    
+    def self.build(command, inc_parameteres = {})
+      collection = []
+      command.config[:parameters].each do |parameter, config|
+        config ||= {}
+        collection << new(command, parameter, config, inc_parameteres[parameter])        
+      end
+      collection
+    end
+    
+    def self.parameters_for_command_line(command_parameters, required_parameters)
+
+      cli_parameters = []
+      command_parameters.each do |parameter|
+        
+        group       = parameter.group.to_s
+        
+        if required_parameters.include?(parameter.name)
+          raise ArgumentError, "Parameter #{ parameter.name } required but not valid" unless parameter.valid?
+          group += '_required'
+        end
+        
+        cli_parameters << { :group => group, :to_cli => parameter.to_cli } if parameter.to_cli 
+      end
+      
+      
+      cli_parameters.sort{ |a,b| COMMAND_LINE_SORT.index(a[:group]) <=> COMMAND_LINE_SORT.index(b[:group]) }.map{ |p| p[:to_cli] }.join(' ')
+    end
+    
+    
+    def initialize(command, name, config, incoming_value = nil)
+      @command           = command
+      @name              = name
+      @value             = incoming_value || config[:default] || nil
+      set_attributes(config)
+    end
+    
+    def to_cli
+      case value
+        when TrueClass
+          return "#{ @prefix } "
+        when String
+          return "#{ @prefix } #{ @value.inspect } "
+        when Array
+          if @multiple
+            string = @value.inject('') do |string, v|
+              string << "#{ @prefix } #{ v } "
+            end
+            return string
+          else
+            string = "#{ @prefix } #{ @value.join(@join) }"
+            return string
+          end
+      else
+        return false
+      end
+    end
+    
+    def valid?
+      !to_cli.is_a?(FalseClass)
+    end
+    
+    def inspect
+      %( * name: #{ @name.to_s.ljust(20) }  group: #{ @group.to_s.ljust(10) }, value: #{ @value.inspect } )
+    end
+    
+    private
+    def set_attributes(config)
+      @required_argument  = config[:required_argument].is_a?(TrueClass)
+      @required_by_action = false
+      @group              = config[:option].nil? ? :argument : :option
+      @multiple           = config[:multiple]
+      @join               = config[:join] || ' '
+      
+      if @group == :option
+        @prefix = config[:option]
+      end
+      
+    end
+
+      
+      
+
+    
+       
+#     
+#     def assert_parameter(name)
+#       build_parameter(name)
+#     end
+#     
+#     def assert_parameter!(name)
+#       build_parameter(name, true)
+#     end
+#     
+#     
+#     # FIXME modularize
+#     def build_parameter(name, required = false) 
+#       config = @parameters[name]
+#       value  = instance_variable_get("@#{ name }")
+#       string = parse_to_cli(name, value, config) || ''
+#       type   = "#{ config[:type] }#{ required ? '_required' : '' }".to_sym
+#       
+#       if required and value.nil?    
+#         raise(ArgumentError, "missing value for paramater #{ name }") if string.nil? and @raise_if_value_nil
+#       end
+#       
+#       { :value => string, :type => type }
+#     end
+#     
+#     def parse_to_cli(name, value, config)
+#       prefix = config[:option] ? config[:option] : ''
+#       if config[:required_argument] and value.nil?
+#         return nil
+#     else
+#       case value
+#         when TrueClass
+#           string = "#{ prefix } "
+#         when String
+#           string = "#{ prefix } #{ value.inspect } "
+#         when Array
+#           if config[:multiple]
+#             string = value.inject('') do |string, v|
+#               string << "#{ prefix } #{ v.inspect } "
+#             end
+#           else
+#             string = "#{ prefix } #{ value.join(',') } "
+#           end
+#         end
+#         return string
+#       end
+#     end
+#         
+#       
+#     
+#     def assert_parameters(inc_parameteres)
+#       valid_parameters = @config[:parameters]
+#       
+#       parameters = valid_parameters.inject({}) do |parameters, parameter|
+#         parameter_name   = parameter.first
+#         parameter_config = parameter.last
+#         
+#         @parameters[parameter_name] = parameter_config
+#         @parameters[parameter_name][:def_value] = inc_parameteres[parameter_name] || (parameter_config and parameter_config[:default] ? parameter_config[:default] : nil)
+#         @parameters[parameter_name][:type]      = parameter_config[:option] ? :option : :argument
+# 
+#         inc_parameteres.delete(parameter_name) 
+#         parameters
+#       end
+#       
+#       
+#       unless inc_parameteres.empty?
+#         raise ArgumentError, "no valid parameter #{ inc_parameteres.keys.join(',') }"
+#       end || parameters
+#     end
+  end
+end

data/lib/lidia/source.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+module Lidia
+  class Source
+    
+    LIDIA_SOURCE_EXTENSION = 'lidia.yml'
+    
+    attr_reader :paths
+    
+    # = Lidia::Source
+    #
+    # This class manage source dir for lidia definition files.
+    def initialize(options = {})
+      @paths = []
+      unless options[:default].is_a?(FalseClass)
+        add_path(File.dirname(File.expand_path(__FILE__))  + '/../../sources')
+      end
+      
+      add_path(options[:include]) if options[:include]
+    end
+    
+    # include paths for definition_files
+    def add_path(paths)
+      case paths
+      when String
+        store_path(paths)
+      when Array
+        paths.each { |path| store_path(path) }
+      else
+        raise(ArgumentError, "Invalid path class for add_path. Expected Array, String, got #{ path.class }")
+      end
+    end
+       
+    def find(program, options = {})
+      definition_file_name = "#{ program }.#{ LIDIA_SOURCE_EXTENSION }"
+      definition_file      = @paths.inject('') do |definition_file, path|
+                                Dir.chdir(path) do |dir|
+                                  definition_file = (File.exist?(File.join(dir, definition_file_name)) ? File.join(dir, definition_file_name) : '') if definition_file.empty? 
+                                  definition_file 
+                                end
+                              end
+      definition_file.empty? ? raise(ArgumentError, "Lidia couldnt find file definition `#{ definition_file }` at #{ @paths.join(', ') }") : definition_file 
+    end
+
+    
+    private
+    def store_path(path)
+      if not File.exists?(path)
+        raise(ArgumentError, "Path #{ path } doesnt exists")
+      elsif not File.directory?(path)
+        raise(ArgumentError, "Path #{ path }  is not directory")
+      else
+        @paths << File.expand_path(path)
+      end
+    end
+  end
+end

data/lidia.gemspec

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'lib', 'lidia')
+
+Gem::Specification.new do |s|
+  s.name = "Lidia"
+  s.version = Lidia::VERSION
+  s.summary = "Lidia is a yml based command contructor class. Aims to be easy to use and to provide an easy way to remember tons of commands"
+  s.description = "Lidia is a yml based command contructor class. Aims to be easy to use and to provide an easy way to remember tons of commands"
+  s.authors = ['Gnoxys' ]
+  s.files = `git ls-files`.split("\n")
+  s.add_runtime_dependency('open4', '0.9.6')
+  
+  s.add_development_dependency('rspec', '~> 2.3.0')
+  
+# s.add_development_dependency('capybara', '~> 0.3.9')
+  # s.add_development_dependency('sqlite3-ruby')
+  if RUBY_VERSION < '1.9'
+    s.add_development_dependency('ruby-debug', '~> 0.10.3')
+  end
+  # s.add_development_dependency('rspec-rails', '~> 2.0.0')
+  # s.add_development_dependency('factory_girl', '~> 1.3.2')
+  # s.add_development_dependency('forgery', '~> 0.3.6')
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/lidia.rb'}"
+puts "Loading lidia gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/sources/dar.lidia.yml

@@ -0,0 +1,96 @@
+:parameters:
+  :create:
+    :option: -c
+    :option_alias: [ --create ]
+    :description:  creates a backup with the name based on <basename>
+    :required_argument: true
+  :extract:
+    :option: -x
+    :option_alias: [ --extract ]
+    :description: extracts files from the given backup
+    :required_argument: true
+  :list:
+    :option: -l
+    :option_alias: [ --list ]
+    :description: lists the contents of the given backup
+    :required_argument: true
+  :test:
+    :option: -t
+    :option_alias: [ --test ]
+    :description: checks the backup integrity
+    :required_argument: true
+  :root_backup:
+    :option:  -R
+    :description: root point to start backup
+    :default: /
+    :required_argument: true
+  :exclude_files:
+    :option: [ -X ]
+    :description: exclude files for backup
+    :default: [ '*.dar' ]
+    :multiple: true
+    :required_argument: true
+  :include_files:
+    :option: [ -I ]
+    :description: exclude files for backup
+    :default: [ ]
+    :multiple: true
+    :required_argument: true
+
+
+  :compression:
+    :option: [ -m ]
+    :value: any
+  :file_size:
+    :option: [ -s ]
+    :default: 3000M
+
+  :no_warn:
+    :option: -w
+    :description: dont warn
+
+  :bzip_compression:
+    :option: [ -y ]
+    :required_argument: false
+
+  :zip_compression:
+    :option: [ -z ]
+    :required_argument: false
+
+  :store_empty_folders:
+    :option: [ -D ]
+  :non_interactive_mode:
+    :option: [ -Q ]
+    :required_argument: false
+
+  :exclude_to_compress:
+    :option: [ -Z ]
+  :exclude_folders:
+    :option: [ -P ]
+    :multiple: true
+
+
+  :decrypt_password:
+    :option: [ -K ]
+  :encrypt_password:
+    :option: [ -J ]
+  :backup_file:
+
+   
+
+
+
+:actions:
+  :do_backup:
+    :parameters:
+      :required:           [ :backup_file, :root_backup ]
+      :optional:           [ :no_warn, :compression, :store_empty_folders, :file_size, :bzip_compression, :non_interactive_mode, :exclude_to_compress, :exclude_files, :exclude_folders, :decrypt_password, :encrypt_password ]
+
+
+
+    # :syntax: '%option{kk1} %option{compression} %option{kk2} %option{dar_file_size} %option{kk3} %option{kk4} %option_required{root_backup} %argument{backup_file}'
+
+
+  
+
+#  -Z '{{exclude_to_compress}}' -P '{{exclude_folders}}' -X '*.dar' -J {{dar_encrypt_password}} -K {{dar_decrypt_password}} {{backup_files}}"

data/sources/gpg.lidia.yml

@@ -0,0 +1,25 @@
+:parameters:
+  :user_key:
+    :option: -r
+    :required_argument: true
+  :encrypt:
+    :option: -e
+  :decrypt_file:
+    :option: -d
+    :description:  decrypt file
+    :required_argument: true
+  :passphrase:
+    :option: --passphrase
+    :description:  passphrase encrypt
+    :required_argument: true
+
+
+:actions:
+  :decrypt_file:
+    :parameters:
+      :required:           [ :decrypt_file ]
+      :optional:           [ :passphrase ] 
+  :encrypt_data:
+    :parameters:
+       :required:         [ :user_key, :encrypt ]
+       :optional:         [ ]

data/sources/ls.lidia.yml

@@ -0,0 +1,11 @@
+:parameters:
+  :columns:
+    :option: -l
+    :description:  listing format
+  :list_what:
+    :description:  what do u want to list?
+:actions:
+  :list_by_columns:
+    :parameters:
+      :required: [ :columns ]
+      :optional: [ :list_what ]

data/spec/lidia/command_spec.rb

@@ -0,0 +1,46 @@
+require './lib/lidia'
+require './lib/lidia/command'
+
+describe Lidia::Command do
+  
+  describe "#creation" do
+    it "should create a new instance of command" do
+      l = Lidia::Command.new('ls')
+    end
+  
+    it "should not create a new instance of command" do
+      begin
+       l = Lidia::Command.new('lss')
+      rescue
+        l.nil?
+      end
+    end
+  end
+  
+  describe "#command_for" do
+    it "should not render ls -l action due columns option does not fix" do
+      l = Lidia::Command.new('ls')
+      begin
+        cmd = l.command_for(:list_by_columns)
+      rescue
+        cmd.nil?
+      end
+    end
+    it "should render ls -l. Argument set by block" do
+      l = Lidia::Command.new('ls') do |li|
+        li.columns = true
+      end
+      l.command_for(:list_by_columns) == "/bin/ls -l"
+    end
+    it "should render ls -l. Argument set by definition_method" do
+      l = Lidia::Command.new('ls')
+      l.columns = true
+      l.command_for(:list_by_columns) == "/bin/ls -l"
+    end
+    
+    
+  end
+  
+  
+  
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: Lidia
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Gnoxys
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-30 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 9
+        - 6
+        version: 0.9.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 10
+        - 3
+        version: 0.10.3
+  type: :development
+  version_requirements: *id003
+description: Lidia is a yml based command contructor class. Aims to be easy to use and to provide an easy way to remember tons of commands
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/lidia.rb
+- lib/lidia/command.rb
+- lib/lidia/parameter.rb
+- lib/lidia/source.rb
+- lidia.gemspec
+- script/console
+- script/destroy
+- script/generate
+- sources/dar.lidia.yml
+- sources/gpg.lidia.yml
+- sources/ls.lidia.yml
+- spec/lidia/command_spec.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Lidia is a yml based command contructor class. Aims to be easy to use and to provide an easy way to remember tons of commands
+test_files: []
+