fedux_org-stdlib 0.3.2 → 0.6.3

data/lib/fedux_org_stdlib/filesystem/exceptions.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  module FileSystem
+    module Exceptions
+      # Raise if path with '..' given
+      class InvalidPath < Exception; end
+
+      #Raised if library is not used correctly
+      class InvalidUsageOfLibrary < Exception; end
+    end
+  end
+end

data/lib/fedux_org_stdlib/logging.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logging/logger'
+
+module FeduxOrgStdlib
+  def self.logger
+    @logger ||= FeduxOrgStdlib::Logging::Logger.new
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

data/lib/fedux_org_stdlib/logging/logger.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/require_files'
+require_library %w{ logger forwardable }
+
+require 'fedux_org_stdlib/logging/severity'
+
+module FeduxOrgStdlib
+  module Logging
+    class Logger
+
+      extend ::Forwardable
+      def_delegators :@logger, :fatal, :warn, :debug, :info, :error, :unknown
+
+      attr_reader :mode
+
+      # Create logger
+      #
+      # @param [Logger] logger (::Logger.new( $stderr ))
+      #   The logger with should be used to output data
+      def initialize(logger = ::Logger.new( $stderr ) )
+        @logger = logger
+        self.mode = :info
+      end
+
+      # Reset logger to ruby logger
+      def reset
+        @logger = ::Logger.new( $stderr )
+      end
+
+      # Change mode of logger: DEBUG, ... + Change the output format
+      #
+      # @param [Symbol] m
+      #   the mode: DEBUG, ...
+      def mode=(m)
+        @mode = m
+
+        case m
+        when :debug
+          @logger.level = ::Logger::DEBUG
+          format_debug
+        when :silent
+          @logger.level = ::Logger::SILENT
+        when :info
+          @logger.level = ::Logger::INFO
+          format_standard
+        else
+          @logger.level = ::Logger::INFO
+          format_standard
+        end
+      end
+
+      private
+
+      def format_debug
+        @logger.formatter = proc { |severity, datetime, progname , msg|
+          debug_msg("%s %s %s: %s\n" % [ datetime, severity, progname, msg ])
+        }
+      end
+
+      def format_standard
+        @logger.formatter = proc { |severity, datetime, _, msg|
+          info_msg( "%s %s: %s\n" % [ datetime, severity, msg ] )
+        }
+      end
+
+      def error_msg(msg)
+        ANSI.red(msg)
+      end
+
+      def info_msg(msg)
+        msg
+      end
+
+      def debug_msg(msg)
+        msg
+      end
+    end
+  end
+end

data/lib/{fedux_org/stdlib → fedux_org_stdlib}/logging/severity.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 class ::Logger
   SILENT = 9999 unless defined? SILENT
 end

data/lib/fedux_org_stdlib/logic_converters.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+require 'fedux_org_stdlib/logic_converters/logic_converter'
+require 'fedux_org_stdlib/logic_converters/on_off_converter'
+require 'fedux_org_stdlib/logic_converters/true_false_converter'
+require 'fedux_org_stdlib/logic_converters/yes_no_converter'
+
+module FeduxOrgStdlib
+  module LogicConverters
+  end
+end

data/lib/{fedux_org/stdlib → fedux_org_stdlib}/logic_converters/exceptions.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module FeduxOrg
   module Stdlib
     module LogicConverters

data/lib/fedux_org_stdlib/logic_converters/logic_converter.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+
+require 'fedux_org_stdlib/logic_converters/on_off_converter'
+require 'fedux_org_stdlib/logic_converters/true_false_converter'
+require 'fedux_org_stdlib/logic_converters/yes_no_converter'
+require 'fedux_org_stdlib/logic_converters/y_n_converter'
+
+module FeduxOrgStdlib
+  module LogicConverters
+    class LogicConverter
+
+      # @param [String, Symbol] type (true_false, yes_no, on_off)
+      #   choose the type of converter which should be used 
+      def initialize(type)
+        @converter = case type.to_s
+                     when 'true_false'
+                       TrueFalseConverter.new
+                     when 'yes_no' 
+                       YesNoConverter.new
+                     when 'on_off' 
+                       OnOffConverter.new
+                     when 'y_n' 
+                       YNConverter.new
+                     else
+                       raise FeduxOrgStdlib::LogicConverters::Exceptions::InvalidType, "Unknown type \"#{type}\" for logic converter. Valid types are \"true_false\", \"yes_no\" or \"on_off\"."
+                     end
+      end
+
+      # @param [true,false] value
+      #   the logic value which should be converted
+      # @return [String]
+      #   the converted value
+      def parse( value )
+        @converter.parse( value )
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/logic_converters/on_off_converter.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+
+module FeduxOrgStdlib
+  module LogicConverters
+    class OnOffConverter
+
+      # @param [true,false] value
+      #   the logic value which should be converted
+      # @return [String]
+      #   the converted value: true => on, false => off, '' => nil
+      #
+      # @example Parse true
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( true ) # on
+      #
+      # @example Parse false
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( false ) # off
+      #   
+      def parse( value )
+        case value
+        when true
+          'on'
+        when false
+          'off'
+        when ''
+          nil
+        else
+          raise FeduxOrgStdlib::LogicConverters::Exceptions::InvalidValue, "Unknown logic value \"#{value}\"."
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/logic_converters/true_false_converter.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+
+module FeduxOrgStdlib
+  module LogicConverters
+    class TrueFalseConverter
+
+      # @param [true,false] value
+      #   the logic value which should be converted
+      # @return [String]
+      #   the converted value: true => 'true', false => 'false', '' => nil
+      #
+      # @example Parse true
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( true ) # 'true'
+      #
+      # @example Parse false
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( false ) # 'false'
+      def parse( value )
+        case value
+        when true
+          'true'
+        when false
+          'false'
+        when ''
+          nil
+        else
+          raise FeduxOrgStdlib::LogicConverters::Exceptions::InvalidValue, "Unknown logic value \"#{value}\"."
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/logic_converters/y_n_converter.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+
+module FeduxOrgStdlib
+  module LogicConverters
+    class YNConverter
+
+      # @param [true,false] value
+      #   the logic value which should be converted
+      # @return [String]
+      #   the converted value: true => y, false => n, '' => nil
+      #
+      # @example Parse true
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( true ) # 'y'
+      #
+      # @example Parse false
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( false ) # 'n'
+      def parse( value )
+        case value
+        when true
+          'y'
+        when false
+          'n'
+        when ''
+          nil
+        else
+          raise FeduxOrgStdlib::LogicConverters::Exceptions::InvalidValue, "Unknown logic value \"#{value}\"."
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/logic_converters/yes_no_converter.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logic_converters/exceptions'
+
+module FeduxOrgStdlib
+  module LogicConverters
+    class YesNoConverter
+      # @param [true,false] value
+      #   the logic value which should be converted
+      # @return [String]
+      #   the converted value: true => yes, false => no, '' => nil
+      #
+      # @example Parse true
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( true ) # 'yes'
+      #
+      # @example Parse false
+      #    converter = FeduxOrgStdlib::LogicConverters::OnOffConverter.new
+      #    converter.parse( false ) # 'no'
+      #   
+      def parse( value )
+        case value
+        when true
+          'yes'
+        when false
+          'no'
+        when ''
+          nil
+        else
+          raise FeduxOrgStdlib::LogicConverters::Exceptions::InvalidValue, "Unknown logic value \"#{value}\"."
+        end
+      end
+    end
+  end
+end

data/lib/fedux_org_stdlib/models.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/models/exceptions'
+require 'fedux_org_stdlib/models/base_model'
+require 'fedux_org_stdlib/models/class_based_model'
+require 'fedux_org_stdlib/models/filesystem_based_model'

data/lib/fedux_org_stdlib/models/base_model.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+require 'fedux_org_stdlib/logging'
+require 'fedux_org_stdlib/models/exceptions'
+require_library %w{ set }
+
+module FeduxOrgStdlib
+  module Models
+    class BaseModel
+
+      include Comparable
+
+      @instances = ::Set.new
+
+      attr_reader :name
+
+      def self.inherited(base)
+        base.instance_variable_set(:@instances, Set.new)
+      end
+
+      def initialize(name)
+        @name = name.to_sym
+        @enabled = false
+      end
+
+      #enable action
+      def enable
+        @enabled = true
+      end
+
+      #check if action is enabled
+      def enabled?(val=true)
+        @enabled == val
+      end
+
+      def name?(name)
+        @name == name
+      end
+
+      def <=>(other)
+        name <=> other.name
+      end
+
+      def eql?(other)
+        name == other.name
+      end
+
+      def hash
+        name.to_s.hash 
+      end
+
+      class << self
+        #attr_accessor :instances
+
+        def register(element)
+          @instances << element
+
+          element
+        end
+
+        def create( *args, &block )
+          if block_given?
+            register( new( *args, &block ) )
+          else
+            register( new( *args ) )
+          end
+        end
+
+        def delete( val )
+          element = self.find( val.to_s.to_sym )
+          raise FeduxOrgStdlib::Exceptions::InstanceNotFound unless element
+          @instances.delete element
+
+          element
+        end
+
+        def clear
+          @instances = Set.new
+        end
+
+        def all
+          @instances.to_a
+        end
+
+        #return all names as string
+        def all_names_as_string(connector=", ")
+          find_all(enabled: true).map(&:name).sort.join(connector)
+        end
+
+        def first
+          @instances.to_a.first
+        end
+
+        def last
+          @instances.to_a.last
+        end
+
+        #enables a specific instance
+        def enable(name)
+          find(name: name).enable
+        rescue NoMethodError => e
+          raise FeduxOrgStdlib::Models::Exceptions::InvalidSearchCriteria, "Sorry I'm not able to enable \"#{name}\". You need to create an instance with name \"#{name}\" first."
+        end
+
+        #finds a single instance
+        def find(criteria = {})
+          find_all(criteria).first
+        end
+
+        #finds all instances
+        def find_all(criteria = {})
+          FeduxOrgStdlib.logger.debug(self) { "Criteria for search: #{ criteria }" }
+          criteria = { name: criteria.to_sym } if criteria.kind_of? Symbol or criteria.kind_of? String
+
+          FeduxOrgStdlib.logger.debug(self) { "Instances to be searched for: #{ @instances.map { |i| "#{i.name} (#{i.class})" }.join(", ") }" }
+          @instances.find_all do |i| 
+            criteria.all? do |c,v|
+
+              FeduxOrgStdlib.logger.debug(self) { "Check method for search: #{ c }" }
+              i.send( "#{c}?".to_sym , v )
+            end
+          end
+        rescue NameError => e
+          raise FeduxOrgStdlib::Models::Exceptions::InvalidSearchCriteria, e.message
+        end
+      end
+
+    end
+  end
+end