hydramata-core 0.1.0

data/lib/hydramata-core.rb

@@ -0,0 +1 @@
+require 'hydramata/core'

data/lib/hydramata/configuration.rb

@@ -0,0 +1,17 @@
+require 'active_support/lazy_load_hooks'
+require 'hydramata/exceptions'
+module Hydramata
+  class Configuration
+    def translator
+      @translator ||= begin
+        require 'hydramata/core/translator'
+        Core::Translator.new(base_scope: ['hydramata', 'core'])
+      end
+    end
+    def translator=(object)
+      raise ConfigurationError.new("Expected #{self.class}#translator to respond_to #translate. #{object.inspect} does not respond to #translate") unless object.respond_to?(:translate)
+      @translator = object
+    end
+  end
+  ActiveSupport.run_load_hooks(:hydramata_configuration, Configuration)
+end

data/lib/hydramata/core.rb

@@ -0,0 +1,42 @@
+require 'hydramata/core/railtie' if defined?(Rails)
+
+module Hydramata
+  if defined?(ActiveSupport::Autoload)
+    extend ActiveSupport::Autoload
+    autoload :Services
+    autoload :Configuration
+  end
+  class << self
+    attr_writer :configuration
+
+    # @see Configuration
+    def configuration
+      require 'hydramata/configuration'
+      @configuration ||= Configuration.new
+    end
+  end
+
+  module_function
+
+  # @see Configuration
+  # @see .configuration
+  def configure(&block)
+    @configuration_block = block
+
+    # The Rails load sequence means that some of the configured Targets may
+    # not be loaded; As such I am not calling configure! instead relying on
+    # Hydra::RemoteIdentifier::Railtie to handle the configure! call
+    configure! unless defined?(Rails)
+  end
+
+  def configure!
+    if @configuration_block.respond_to?(:call)
+      @configuration_block.call(configuration)
+      @configuration_block = nil
+    end
+  end
+  private :configure!
+
+  module Core
+  end
+end

data/lib/hydramata/core/named_callbacks.rb

@@ -0,0 +1,24 @@
+module Hydramata
+  module Core
+    # Responsible for registering blocks used for callbacks.
+    class NamedCallbacks
+      def initialize
+        @callbacks = {}
+      end
+
+      def method_missing(callback_name, *args, &block)
+        @callbacks[callback_name] = block
+      end
+
+      def respond_to_missing?(callback_name)
+        @callbacks[callback_name]
+      end
+
+      def call(callback_name, *args)
+        callback_name = callback_name.to_sym
+        callback = @callbacks[callback_name]
+        callback ? callback.call(*args) : true
+      end
+    end
+  end
+end

data/lib/hydramata/core/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails/railtie'
+
+module Hydramata
+  module Core
+    class Railtie < Rails::Railtie
+      config.eager_load_namespaces << Hydramata::Core
+      config.to_prepare do
+        # Because I want allow for other components to plug into Hydramata's
+        # configuration. Maybe there is a better way to do this.
+        Hydramata.send(:configure!)
+      end
+    end
+  end
+end

data/lib/hydramata/core/runner.rb

@@ -0,0 +1,58 @@
+module Hydramata
+  module Core
+    # A Runner is responsible for performing the guts of what might traditionally
+    # be a controller's action.
+    #
+    # It exists for two reasons:
+    # * Controllers are extremely over-worked (parameter negotiation,
+    #   authentication, authorization, marshalling an object, user messages via
+    #   flash, and http response determination)
+    # * The inner method content of a controller's action is subject to change
+    #   especially as other implementors look to change the behavior.
+    #
+    # So, the Runner provides a seem in the code in which you can more readily
+    # make changes to the "inner method"  of a route. In some ways, I see this as
+    # a separation of state change and response; a somewhat analogous separation
+    # to the Command/Query separation principle.
+    #
+    # @See Services
+    class Runner
+      attr_reader :context
+
+      def self.run(context,*args,&block)
+        new(context, &block).run(*args)
+      end
+
+      def initialize(context, collaborators = {})
+        @callbacks = collaborators.fetch(:callbacks) { default_callbacks }
+        self.context = context
+        yield(@callbacks) if block_given?
+      end
+
+      def callback(name, *args)
+        @callbacks.call(name, *args)
+        args
+      end
+
+      def services
+        context.services
+      end
+
+      def run(*args)
+        raise NotImplementedError.new("You must define #{self.class}#run")
+      end
+      protected
+
+      def context=(object)
+        raise RuntimeError.new("Expected #{object.inspect} to implement #services") unless object.respond_to?(:services)
+        @context = object
+      end
+
+      private
+      def default_callbacks
+        require 'hydramata/core/named_callbacks'
+        NamedCallbacks.new
+      end
+    end
+  end
+end

data/lib/hydramata/core/translator.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/array/wrap'
+
+module Hydramata
+  module Core
+    # Responsible for handling the translation via diminishing specificity.
+    class Translator
+
+      class << self
+        def translate(key, options = {})
+          new(options).translate(key, options)
+        end
+        alias_method :t, :translate
+      end
+
+      attr_reader :base_scope, :translation_service, :translation_service_error
+      def initialize(options = {})
+        self.base_scope = options.fetch(:base_scope) { default_base_scope }
+        @translation_service = options.fetch(:translation_service) { default_translation_service }
+        @translation_service_error = options.fetch(:translation_service_error) { default_translation_service_error }
+      end
+
+      def translate(key, options = {})
+        translate_key_for_specific_scopes(key, options) || translate_key_for_general_case(key, options)
+      end
+      alias_method :t, :translate
+
+      private
+
+      def translate_key_for_specific_scopes(key, options = {})
+        return nil unless scopes = options[:scopes]
+        returning_value = nil
+        Array.wrap(scopes).each do |scope|
+          begin
+            options_to_use = options.merge(scope: base_scope + Array.wrap(scope), raise: true)
+            options_to_use.delete(:scopes)
+            options_to_use.delete(:default)
+            returning_value = translation_service.translate(key, options_to_use)
+            break
+          rescue *translation_service_error => e
+            STDOUT.puts(e) if ENV['DEBUG']
+            next
+          end
+        end
+        returning_value
+      end
+
+      def translate_key_for_general_case(key, options = {})
+        options_to_use = options.merge(scope: base_scope)
+        options_to_use.delete(:scopes)
+        translation_service.translate(key, options_to_use)
+      end
+
+      def base_scope=(values)
+        @base_scope = Array.wrap(values)
+      end
+
+      def default_base_scope
+        ['hydramata', 'core']
+      end
+
+      def default_translation_service_error
+        require 'i18n/exceptions'
+        I18n::ArgumentError
+      end
+
+      def default_translation_service
+        require 'i18n'
+        I18n
+      end
+    end
+  end
+end

data/lib/hydramata/core/version.rb

@@ -0,0 +1,5 @@
+module Hydramata
+  module Core
+    VERSION = '0.1.0'
+  end
+end

data/lib/hydramata/exceptions.rb

@@ -0,0 +1,4 @@
+module Hydramata
+  class ConfigurationError < RuntimeError
+  end
+end

data/lib/hydramata/services.rb

@@ -0,0 +1,21 @@
+require 'active_support/lazy_load_hooks'
+require 'active_support/dependencies/autoload'
+module Hydramata
+  # The Services class is a dumping ground for methods. These methods are
+  # exposed to an application's context (i.e. a controller).
+  #
+  # It is the application's interface between the logic of the controller/
+  # request handling and the construction of objects.
+  #
+  # This class has been constructed such that other engines can inject
+  # behavior into Services using the ActiveSupport.on_load method.
+  #
+  # @see Runner
+  class Services
+    def initialize(context)
+      @context = context
+    end
+    attr_reader :context
+  end
+  ActiveSupport.run_load_hooks(:hydramata_services, Services)
+end

data/lib/hydramata_core.rb

@@ -0,0 +1,2 @@
+# A convenience/courtesy file for adopters of this gem.
+require 'hydramata/core'

data/lib/tasks/hydramata_mecha_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :hydramata/work do
+#   # Task goes here
+# end

data/run_each_spec_in_isolation

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby -w
+require 'time'
+require 'rake'
+require 'benchmark'
+
+  FileList['spec/**/*_spec.rb'].sort.select do |fn|
+    puts "rspec #{fn}"
+    system "rspec #{fn}"
+  end
+  system('rspec')
+end

data/script/analyzer.rb

@@ -0,0 +1,124 @@
+#!/usr/local/bin/ruby
+
+require 'pp'
+require 'sexp_processor'
+require 'ruby_parser'
+require 'byebug'
+require 'rake'
+require 'set'
+
+class Collector
+  attr_reader :namespace
+  def initialize(namespace)
+    @namespace = namespace
+    @storage = {}
+  end
+
+  def push(class_stack, collaborator)
+    klass = register(class_stack)
+    @storage[klass] << collaborator
+  end
+
+  def register(class_stack)
+    klass = class_stack.reverse[0..-1].collect(&:to_s).join('::')
+    @storage[klass] ||= Set.new
+    klass
+  end
+
+  def render
+    puts %(digraph "G" {)
+    puts %(    label="#{namespace}") if namespace
+    @storage.each do |klass, collaborators|
+      if klass.strip != '' || collaborators.any? {|c| c =~ /\A#{namespace}/ }
+        puts render_node(klass)
+        collaborators.each do |collaborator|
+          if @storage.detect do |some_class, _|
+              if some_class =~ /\A#{namespace}(::\w+)*::#{collaborator}\Z/
+                render_node(some_class)
+                render_edge(klass, some_class)
+                true
+              else
+                false
+              end
+            end
+          else
+            if collaborator =~ /\A#{namespace}/
+              render_node(collaborator)
+              render_edge(klass, collaborator)
+            end
+          end
+        end
+      end
+    end
+    puts %(})
+  end
+
+  def render_node(klass)
+    puts %(    #{to_dot_name(klass)}[label="#{klass}"])
+  end
+
+  def render_edge(from, to)
+    puts %(    #{to_dot_name(from)} -> #{to_dot_name(to)})
+  end
+
+  def to_dot_name(str)
+    str.gsub(/[\W:]+/,'_')
+  end
+end
+
+class DependencyAnalyzer < MethodBasedSexpProcessor
+
+  attr_reader :collector
+
+  def initialize(collector = Collector.new)
+    super()
+    @collector = collector
+  end
+
+  def process_colon2(exp)
+    klass = classify_colon2(exp).join("::")
+    collector.push(class_stack, klass)
+    return exp
+  end
+
+  def process_module(exp)
+    super(exp)
+    collector.register(class_stack)
+    return exp
+  end
+
+  def process_dfn(exp)
+    collector.register(class_stack)
+    return exp
+  end
+
+  def process_const(exp)
+    collaborator = exp[1]
+    collector.push(class_stack, collaborator.to_s)
+    return s(:const, collaborator)
+  end
+
+  def classify_colon2(exp, returning = [])
+    returning.unshift(exp[2]) if exp[2]
+    if exp[1].is_a?(Sexp)
+      classify_colon2(exp[1], returning)
+    else
+      returning.unshift(exp[1])
+    end
+    return returning
+  end
+
+end
+
+if __FILE__ == $0
+  collaborator = Collector.new('Hydramata::Core')
+  analyzer = DependencyAnalyzer.new(collaborator)
+  FileList['app/**/*.rb', 'lib/**/*.rb'].each do |filename|
+  # filename = '/Users/jfriesen/Repositories/hydramata-work/app/parsers/hydramata/core/predicate_parsers/simple_parser.rb'
+    file_content = File.read(filename)
+    parsed_file = RubyParser.for_current_ruby.parse(file_content)
+    # break
+    analyzer.process(parsed_file)
+  end
+  collaborator.render
+end

data/script/fast_specs

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby -w
+
+require 'rake'
+
+# A helper function for answering: Does this spec run fast?
+module Fast
+  module_function
+  def spec?(fn)
+    open(fn) { |f| f.gets =~ /spec_fast_helper/ }
+  end
+end
+
+fast_specs = FileList['spec/**/*_spec.rb'].select do |fn|
+  Fast.spec?(fn)
+end
+
+if fast_specs.any?
+  system "rspec #{fast_specs}"
+else
+  puts 'Unable to find any fast specs'
+  exit(-1)
+end