Module: AeEasy::Core

Defined in:
lib/ae_easy/core.rb,
lib/ae_easy/core/mock.rb,
lib/ae_easy/core/config.rb,
lib/ae_easy/core/helper.rb,
lib/ae_easy/core/plugin.rb,
lib/ae_easy/core/version.rb,
lib/ae_easy/core/exception.rb,
lib/ae_easy/core/mock/fake_db.rb,
lib/ae_easy/core/helper/cookie.rb,
lib/ae_easy/core/plugin/parser.rb,
lib/ae_easy/core/plugin/seeder.rb,
lib/ae_easy/core/mock/fake_parser.rb,
lib/ae_easy/core/mock/fake_seeder.rb,
lib/ae_easy/core/smart_collection.rb,
lib/ae_easy/core/mock/fake_executor.rb,
lib/ae_easy/core/plugin/config_behavior.rb,
lib/ae_easy/core/plugin/initialize_hook.rb,
lib/ae_easy/core/plugin/parser_behavior.rb,
lib/ae_easy/core/plugin/seeder_behavior.rb,
lib/ae_easy/core/plugin/collection_vault.rb,
lib/ae_easy/core/exception/outdated_error.rb,
lib/ae_easy/core/plugin/context_integrator.rb

Defined Under Namespace

Modules: Exception, Helper, Mock, Plugin Classes: Config, SmartCollection

Constant Summary collapse

VERSION =

Gem version

"0.0.5"

Class Method Summary collapse

Class Method Details

.all_scripts(dir, opts = {}) {|path| ... } ⇒ Object

Execute an action for all scripts within a directory.

Parameters:

  • dir (String) —

    Directory containing `.rb` scripts.

  • opts (Hash) (defaults to: {}) —

    ({}) Configuration options.

Options Hash (opts):

  • :except (Array) — default: nil —

    Literal file collection excluded from process.

Yield Parameters:

  • path (String) —

    Script file path.



30
31
32
33
34
35
 
# File 'lib/ae_easy/core.rb', line 30

def all_scripts dir, opts = {}, &block
  excluded_files = (opts[:except] || []).map{|f|File.expand_path File.join(dir, f)}
  files = Dir[File.join(File.expand_path(dir), '*.rb')] - excluded_files
  block ||= proc{}
  files.sort.each &block
end

.analyze_compatibility(source, fragment) ⇒ Hash

Generate a compatibility report from a source and a fragment as a hash.

Examples:

Analyze when uncompatible `fragment` because of `source` missing fields.

AeEasy::Core.analyze_compatibility [1,2,3,4,5], [1,2,6]
# => {missing: [6], new: [3,4,5], is_compatible: false}

Analyze when compatible.

AeEasy::Core.analyze_compatibility [1,2,3,4,5], [1,2,3]
# => {missing: [], new: [4,5], is_compatible: true}

Parameters:

  • source (Array) —

    Item collection to represent the universe.

  • fragment (Array) —

    Item collection to compare againt source.

Returns:

  • (Hash) —

    • `:missing [Array]` (`[]`) Methods on `fragment` only.

    • `:new [Array]` (`[]`) Methods on `source` only.

    • `:is_compatible [Boolean]` true when all `fragment`'s methods are present on `source`.



191
192
193
194
195
196
197
198
 
# File 'lib/ae_easy/core.rb', line 191

def analyze_compatibility source, fragment
  intersection = source & fragment
  {
    missing: fragment - intersection,
    new: source - intersection,
    is_compatible: (intersection.count == fragment.count)
  }
end

.deep_clone(hash, should_clone = false) ⇒ Hash

Deep clone a hash while keeping it's values object references.

Parameters:

  • hash (Hash) —

    Hash to clone.

  • should_clone (Boolean) (defaults to: false) —

    (false) Clone values when true.

Returns:

  • (Hash) —

    Hash clone.



232
233
234
235
236
237
238
239
 
# File 'lib/ae_easy/core.rb', line 232

def deep_clone hash, should_clone = false
  target = {}
  hash.each do |key, value|
    value = value.is_a?(Hash) ? deep_clone(value, should_clone) : (should_clone ? value.clone : value)
    target[key] = value
  end
  target
end

.deep_stringify_keys(hash, should_clone = true) ⇒ Hash

Deep stringify keys from a hash.

Parameters:

  • hash (Hash) —

    Source hash to stringify keys.

  • should_clone (Boolean) (defaults to: true) —

    (true) Target a hash clone to avoid affecting the same hash object.

Returns:

  • (Hash) 


206
207
208
209
210
211
212
213
214
215
 
# File 'lib/ae_easy/core.rb', line 206

def deep_stringify_keys hash, should_clone = true
  pair_collection = hash.map{|k,v| [k.to_s,v]}
  target = should_clone ? {} : hash
  target.clear
  pair_collection.each do |pair|
    key, value = pair
    target[key] = value.is_a?(Hash) ? deep_stringify_keys(value, should_clone) : value
  end
  target
end

.deep_stringify_keys!(hash) ⇒ Hash

Deep stringify all keys on hash object.

Parameters:

  • hash (Hash) —

    Hash to stringify keys.

Returns:

  • (Hash) 


222
223
224
 
# File 'lib/ae_easy/core.rb', line 222

def deep_stringify_keys! hash
  deep_stringify_keys hash, false
end

.expose_to(object, env) ⇒ Object

Expose an environment into an object instance as methods.

Examples:

class Foo
  def hello_person
    'Hello person!'
  end
end

env = {
  hello_world: lambda{return 'Hello world!'},
  hello_sky: proc{return 'Hello sky!'}
}
my_object = Foo.new
AeEasy::Core.expose_to my_object, env

puts my_object.hello_world
# => 'Hello world!'
puts my_object.hello_sky
# => 'Hello sky!'
puts my_object.hello_person
# => 'Hello person!'

Parameters:

  • object —

    Object instance to expose env into.

  • env (Array) —

    Hash with methods name as keys and blocks as actions.

Returns:

  • `object`



92
93
94
95
96
97
98
 
# File 'lib/ae_easy/core.rb', line 92

def expose_to object, env
  metaclass = class << object; self; end
  env.each do |key, block|
    metaclass.send(:define_method, key, block)
  end
  object
end

.instance_methods_from(object) ⇒ Array

Retrieve instance methods from an object.

Examples:

class Foo
  def hello_world
    'Hello world!'
  end

  def hello_person
    'Hello person!'
  end
end

my_object = Foo.new
AeEasy::Core.instance_methods_from my_object
# => [:hello_world, :hello_person]

Parameters:

  • object —

    Object with instance methods.

Returns:

  • (Array) 


120
121
122
 
# File 'lib/ae_easy/core.rb', line 120

def instance_methods_from object
  object.methods(false) - Object.new.methods(false)
end

.mock_instance_methods(source, target) ⇒ Object

Mock instances methods from the source into target object.

Examples:

class Boo
  attr_accessor :message
  def initialize
    message = 'Hello world!'
  end

  def hello_world
    message
  end
end

class Foo
  def hello_person
    'Hello person!'
  end
end

source = Boo.new
target = Foo.new
AeEasy::Core.mock_instance_methods source target

puts target.hello_world
# => 'Hello world!'
puts target.hello_person
# => 'Hello person!'

source.message = 'Hello world again!'
puts target.hello_world
# => 'Hello world again!'

Parameters:

  • source —

    Object with instance methods to mock.

  • target —

    Object instance to mock methods into.



159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/ae_easy/core.rb', line 159

def mock_instance_methods source, target
  # Get instance unique methods
  method_list = instance_methods_from source
  method_list.delete :context_binding if method_list.include? :context_binding

  # Build env reflecting source unique methods
  env = {}
  method_list.each do |method|
    env[method] = lambda{|*args|source.send(method, *args)}
  end

  # Mock source unique methods into target
  expose_to target, env
end

.require_all(dir, opts = {}) ⇒ Object

Require all scripts within a directory.

Parameters:

  • dir (String) —

    Directory containing `.rb` scripts.

  • opts (Hash) (defaults to: {}) —

    ({}) Configuration options.

Options Hash (opts):

  • :except (Array) — default: nil —

    Literal file collection excluded from process.



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/ae_easy/core.rb', line 42

def require_all dir, opts = {}
  real_dir = options = nil
  real_except = []
  $LOAD_PATH.each do |load_path|
    real_dir = File.join load_path, dir
    next unless File.directory? real_dir
    real_except = (opts[:except] || []).map{|f| "#{f}.rb"}
    options = opts.merge except: real_except
    all_scripts(real_dir, options) {|file| require file}
  end
end

.require_relative_all(dir, opts = {}) ⇒ Object

Require all relative scripts paths within a directory.

Parameters:

  • dir (String) —

    Directory containing `.rb` scripts.

  • opts (Hash) (defaults to: {}) —

    ({}) Configuration options.

Options Hash (opts):

  • :except (Array) — default: nil —

    Literal file collection excluded from process.



59
60
61
62
63
 
# File 'lib/ae_easy/core.rb', line 59

def require_relative_all dir, opts = {}
  real_except = (opts[:except] || []).map{|f| "#{f}.rb"}
  options = opts.merge except: real_except
  all_scripts(dir, options) {|file| require file}
end