domain_neutral 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54827517aef3ef85bc7fc7611cc8e6e8eb2ca76d
+  data.tar.gz: 4daf91bc5ef08666fb404936acf55b862392a444
+SHA512:
+  metadata.gz: 8a63fe76ae198a714472a9abb3414000ef66f9243369b8095c483ac0c70a4cf3f0b4fdc65a795a0d198027eb2390622a3a6b1a88a2d9a57d7ca9f1642309b8f3
+  data.tar.gz: f83b2574943c1a25f9abb0efcb74c8b1ad8c3b44b55cbfdf8d43f57eba69a9134348f354a4b30a99df93e131adc1281dcc00bfc4167eda3a4ea5dea29d61c0b4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 knut
+
+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,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DomainNeutral'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/models/domain_neutral/descriptor.rb

@@ -0,0 +1,55 @@
+#require 'descriptor_model/symbolized_class'
+module DomainNeutral
+  class Descriptor < ActiveRecord::Base
+    include SymbolizedClass
+    include Comparable
+    # Enable caching by default
+
+    belongs_to :parent, :polymorphic => true
+    validates_presence_of :name, :symbol
+    validates_uniqueness_of :symbol, scope: :type
+    
+    class << self
+      def symbols
+        @symbols ||= begin
+          # ensure that we really have some items stored. This method may be called before fixtures are loaded in test environment
+          s = all.map(&:symbol)
+          s.size.zero? ? nil : s
+        end
+      end
+    end
+  
+    def <=>(other)
+    	index <=> other.index
+    end
+
+    def ==(other)
+    	self.class == other.class && symbol == other.symbol
+    end
+
+    def !=(other)
+    	self.class == other.class && symbol != other.symbol
+    end
+
+    def to_i
+      id
+    end
+  
+    def name
+      t :name
+    end
+
+    def description
+      t :description
+    end
+
+  protected
+    def i18n_scope
+      @i18n_scope ||= [:descriptors, self.class.to_s.underscore, to_sym ]
+    end
+
+    def t(attribute)
+      I18n.t( attribute, scope: i18n_scope, default: self[attribute] || '') # || '' here is used to fix validation
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/db/migrate/20160531124022_create_domain_neutral_descriptors.rb

@@ -0,0 +1,20 @@
+class CreateDomainNeutralDescriptors < ActiveRecord::Migration
+  def change
+    table_name = DomainNeutral::Descriptor.table_name
+    create_table table_name, :force => true do |t|
+      t.string   "type"
+      t.string   "parent_type"
+      t.integer  "parent_id"
+      t.string   "symbol"
+      t.string   "name"
+      t.text     "description"
+      t.integer  "index"
+      t.integer  "value"
+      t.timestamps null: false
+    end
+
+    add_index table_name, ["type", "symbol"],           name: "index_#{table_name}_on_type_and_symbol"
+    add_index table_name, ["type", "index"],            name: "index_#{table_name}_on_type_and_index"
+    add_index table_name, ["parent_type", "parent_id"], name: "index_#{table_name}_on_parent_type_and_parent_id"
+  end
+end

data/lib/domain_neutral/association.rb

@@ -0,0 +1,21 @@
+module DomainNeutral
+  module Association
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def has_descriptor(name, options = {})
+        # TODO: add delegate method
+        belongs_to name, options
+        r = reflect_on_association(name)
+        class_eval <<-CODE, __FILE__, __LINE__
+          def #{name}
+            #{r.klass}.find(#{r.foreign_key})
+          end
+        CODE
+      end
+    end
+  end
+end
+class ActiveRecord::Base
+  include DomainNeutral::Association
+end

data/lib/domain_neutral/engine.rb

@@ -0,0 +1,5 @@
+module DomainNeutral
+  class Engine < ::Rails::Engine
+    isolate_namespace DomainNeutral
+  end
+end

data/lib/domain_neutral/railtie.rb

@@ -0,0 +1,24 @@
+require "rails"
+
+module DomainNeutral
+  # = Domain Neutral Railtie
+  class Railtie < Rails::Railtie
+    config.domain_neutral = ActiveSupport::OrderedOptions.new
+    config.domain_neutral.seed = ActiveSupport::OrderedOptions.new
+    
+    
+    config.domain_neutral.table_prefix = 'domain_neutral' # Table prefix
+    config.domain_neutral.cache = true                    # Use cache
+    config.domain_neutral.seed.master_locale = :en        # Default master data locale. Language used for seeding
+    config.domain_neutral.seed.locale_alternatives = []   # Alternative locale data. These will be parsed and checked for consistency with the master
+    config.domain_neutral.seed.verbose = true             # Display progress when seeding
+    config.domain_neutral.seed.create_fixtures = true     # Create fixtures from master file
+    
+    initializer 'domain_neutral.configure' do |app|
+      DomainNeutral::Descriptor.table_name = app.config.domain_neutral.table_prefix.blank? ? 
+        'descriptors' : "#{app.config.domain_neutral.prefix}_#{table_name}"
+      DomainNeutral::Descriptor.caching_enabled = app.config.domain_neutral.cache
+      DomainNeutral.seed_options = config.domain_neutral.seed
+    end
+  end
+end

data/lib/domain_neutral/seed.rb

@@ -0,0 +1,8 @@
+require 'domain_neutral/seeder/descriptors'
+module DomainNeutral
+  class Seed
+    def descriptors(callee)
+      Seeder::Descriptors.seed(callee)
+    end
+  end
+end

data/lib/domain_neutral/seeder/descriptors.rb

@@ -0,0 +1,195 @@
+# Seeds descriptors from yml file, using norwegian as default
+module DomainNeutral
+  module Seeder
+    class Descriptors      
+      def self.seed(context)
+        seeder = new(context)
+        seeder.setup
+        seeder.load_master_data
+        seeder.validate_master
+        seeder.validate_locale_alternatives
+        seeder.create_fixtures_file
+        seeder.seed_parents
+        seeder.seed_everything_else
+      end
+      
+      def initialize(context)
+        @context = context
+      end
+      
+      def seed_options
+        DomainNeutral.seed_options
+      end
+      
+      delegate :verbose, :master_locale, :locale_alternatives, :create_fixtures, to: :seed_options
+      
+      def setup
+        if DomainNeutral.rails_generation < 4
+          Descriptor.attr_accessible :name, :description, :index, :externalid, :parent, :value
+        end
+        Descriptor.enable_caching false
+      end
+      
+      attr_reader :master
+      
+      # Load master descriptors from yaml file
+      def load_master_data
+        #@master = load_yaml(DomainNeutral.master_locale, :master)
+        @master = load_yaml(master_locale, :master)
+      end
+      
+      def seed_parents
+        # Collect parents
+        log "Collect parents"
+        parents = []
+        master.each do |descriptor_set, descriptors|
+          parents << descriptors[:parent] if descriptors[:parent]
+        end
+        log "Parents collected: #{parents.inspect}"
+        # Seed parents
+        return if parents.empty?
+        log "Seed parents"
+        parents.map { |p| p.split('.')[0].underscore }.uniq.each do |parent|
+          klass = parent.classify.constantize
+          # Create only objects of Descriptor class
+          if klass.new.is_a?( Descriptor) && section = master.delete(parent)
+            seed_descriptor_set parent, section
+          end
+        end
+      end
+      
+      def seed_everything_else
+        # seed rest
+        master.each do |descriptor_set, descriptors|
+          seed_descriptor_set descriptor_set, descriptors
+        end
+      end
+      
+      # Validate descriptors in master yaml file
+      def validate_master
+        log 'Validating master locale file'
+        undefined = []
+        master.each do |descriptor_set, descriptors|
+          descriptors.reject { |k,v| k == 'parent'  }.each do |symbol, descriptor|
+            unless descriptor[:name]
+              undefined << "Name not defined for #{descriptor_set}"
+            end    
+          end
+        end
+        abort undefined if undefined.size > 0
+      end
+      
+      def validate_locale_alternatives
+        undefined = []
+        #DomainNeutral.locale_alternatives.each do |locale|
+        locale_alternatives.each do |locale|
+          log "Validating alternative locale file: #{locale}"
+          loc_descriptors = load_yaml(locale, 'locale_alternative')
+          master.each do |descriptor_set, descriptors|
+            unless loc_descriptors[descriptor_set]
+              undefined << "Locale: #{locale}. Keys not defined for '#{descriptor_set}'"
+              next      
+            end
+            descriptors.keys.reject{ |k| k == 'parent' }.each do |descriptor|
+              unless loc_descriptors[descriptor_set][descriptor]
+                undefined << "Locale: #{locale}. Key not defined for '#{descriptor}' in '#{descriptor_set}'" 
+                next      
+              end
+              %w(name description).each do |key|
+                if descriptors[descriptor][key] && !loc_descriptors[descriptor_set][descriptor][key]
+                  undefined << "Locale: #{locale}. Attribute '#{key}' not defined for '#{descriptor}' in '#{descriptor_set}'"
+                end
+              end
+            end
+          end
+        end
+        abort undefined if undefined.size > 0
+      end
+      
+      def create_fixtures_file
+        return unless create_fixtures
+        fixtures = {}
+        master.each do |descriptor_set, descriptors|
+          base = {type: descriptor_set.classify}
+          if parent = descriptors[:parent]
+            abort "Parent for fixtures not yet implemented.", descriptors.inspect
+            base[:parent] = parent
+          end
+          descriptors.reject { |k,v| k == 'parent'  }.each do |symbol, descriptor|
+            fixtures["#{descriptor_set}_#{symbol}"] = descriptor.merge(base.merge(symbol: symbol)).to_hash
+          end
+        end
+        path = fixtures_path.join('domain_neutral', 'descriptors.yml')
+        FileUtils.mkdir_p path.dirname
+        File.open(path, 'w') do |f|
+          f.write fixtures.to_yaml
+        end
+        log "Seeders file created (#{path}):"
+      end
+      
+    private
+      def load_yaml(locale, type)
+        file = locate_locale_file(locale, type)
+        yml = HashWithIndifferentAccess.new YAML.load_file(file.to_s)
+        yml[locale.to_sym][:descriptors]
+      end
+      
+      def locate_locale_file(locale, type)
+        alternative_locations = [
+          Rails.root.join('config', 'locales', locale.to_s, "descriptors.yml"),
+          Rails.root.join('config', 'locales', "#{locale}.descriptors.yml"),
+          Rails.root.join('config', 'locales', "#{locale}.yml"),
+          Rails.root.join('config', 'locales', "descriptors.yml")
+        ]
+        unless file = alternative_locations.select { |fname| fname.exist? }.first
+          abort "Could not load #{type} file for descriptors. Expected to find any of the following files:\n" + 
+            alternative_locations.map { |fname| "\t'#{fname}'" }.join("\n")
+        end
+        file
+      end
+
+      def seed_descriptor_set(descriptor_set, descriptors, default_parent = nil)
+        log "seed_descriptor_set: #{descriptor_set.inspect}, descriptors: #{descriptors.inspect}"
+        klass = descriptor_set.classify.constantize
+        default_parent = descriptors.delete('parent')
+        descriptors.each do |descriptor, keypairs|
+          log "descriptor: #{descriptor.inspect}, keypairs: #{keypairs.inspect}"
+          parent = keypairs['parent'] || default_parent || 'nil'
+          unless object = klass[descriptor]
+            if DomainNeutral.rails_generation < 4
+              klass.create! keypairs.merge(symbol: descriptor, parent: eval(parent)), without_protection: true
+            else
+              klass.create! keypairs.merge(symbol: descriptor, parent: eval(parent))
+            end
+          else
+            if DomainNeutral.rails_generation < 4
+              object.update_attributes(keypairs.merge(parent: eval(parent)), without_protection: true)
+            else
+              object.update_attributes(keypairs.merge(parent: eval(parent)))
+            end
+          end
+        end
+      end
+      
+      def fixtures_path
+        if ENV['FIXTURES_PATH']
+          Rails.root.join(ENV['FIXTURES_PATH'])
+        else
+          Rails.root.join('test', 'fixtures')
+        end
+      end
+      def abort(*messages)
+        raise "#{self.class.name}: #{messages.join("\n")}"
+      end
+      
+      def log(message)
+        # @context.say message if DomainNeutral.verbose_seed
+        if verbose
+          @messenger ||= @context.is_a?( ActiveRecord::Migration) ? :say : :puts
+          @context.send @messenger,  message
+        end
+      end
+      
+    end
+  end
+end

data/lib/domain_neutral/symbolized_class.rb

@@ -0,0 +1,170 @@
+module DomainNeutral
+  module SymbolizedClass
+    # = Domain Neutral SymbolizedClass
+    #
+    # This mudule implements two important features:
+    # * access (finding) to objects, using a symbol
+    # * cache of objects that imcludes this module, if enabled
+    #
+    # A requirement for including this module is that the class has an attribute named symbol.
+    #
+    # Usage:
+    #
+    #     class MySymbolizedClass < ActiveRecord::Base
+    #       include DomainNeutral::SymbolizedClass
+    #       ...
+    #     end
+    
+    
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :caching_enabled
+      after_save :flush_cache, if: :caching_enabled
+    end
+
+    module ClassMethods
+      # Access descriptor by symbol, e.g.
+      #
+      #   Role[:manager]
+      #   => Manager role
+      #   Same as Role.where(symbol: :manager).first
+      def [](symbol)
+        find_by_symbol(symbol)
+      end
+
+      # Access like Role.manager
+      #
+      #   Role.manager
+      #   => Manager role
+      #   Same as Role.where(symbol: :manager).first
+      def method_missing(method, *args)
+        begin
+          if method != :find_by_symbol
+            if obj = find_by_symbol(method)
+              redefine_method method do
+                find_by_symbol(method)
+              end
+              return obj
+            end
+          end
+        rescue
+          # Ignore errors, and call super
+        end
+        super
+      end
+
+      # Overrides find by using cache.
+      # The key in cache is [class_name, id] or ':class_name/:id', e.g. 'Role/1'
+      def find(id)
+        if caching_enabled
+          Rails.cache.fetch([name, id]) { super }
+        else
+          super
+        end
+      end
+      
+      # Find object by symbol
+      #
+      # See also
+      #   Descriptor[:symbol]
+      #   Descriptor.symbol
+      def find_by_symbol(symbol)
+        if caching_enabled
+          Rails.cache.fetch([name, symbol.to_s]) do
+            where(symbol: symbol).first
+          end
+        else
+          where(symbol: symbol).first
+        end
+      end
+
+      # Role.collection(:site_admin, :user_admin, :admin)
+      # => Role[] consisting of Role.site_admin, Role.user_admin, Role.admin
+      def collection(*syms)
+        syms.flatten.map { |s| self[s] }
+      end
+  
+
+      # Turn cache on or off
+      # Calling enable_caching without parameter or true will turn on caching
+      # By default cache is off. 
+      #
+      # Example - enabling caching
+      #     class MySymbolizedClass < ActiveRecord::Base
+      #       include DomainNeutral::SymbolizedClass
+      #       enable_caching
+      #       ...
+      #     end
+      #
+      # Example - disable caching
+      #     class MySymbolizedClass < ActiveRecord::Base
+      #       include DomainNeutral::SymbolizedClass
+      #       enable_caching false
+      #       ...
+      #     end
+      
+      def enable_caching(*args)
+        self.caching_enabled = args.size > 0 ? args.first : true
+      end
+    end
+
+    # Store symbol
+    def symbol=(name)
+      write_attribute(:symbol, name.to_s)
+    end
+
+    # Retrieve symbol
+    def symbol
+      @symbol ||= begin
+        s = read_attribute(:symbol)
+        s && s.to_sym
+      end
+    end
+
+    def to_sym
+      symbol
+    end
+
+    # Role.admin.is_one_of?(:admin, :site_admin)
+    # => true
+    # Role.admin.is_one_of?(:site_admin, :user_admin)
+    # => false
+    def is_one_of?(*syms)
+      syms.flatten.include?(to_sym)
+    end
+  
+    # Role.admin.is_none_of?(:site_admin, :user_admin)
+    # => true
+    # Role.admin.is_none_of?(:admin, :site_admin)
+    # => false
+    def is_none_of?(*syms)
+      !syms.flatten.include?(to_sym)
+    end  
+
+    # Allow to test for a specific role or similar like Role.accountant?
+    def method_missing(method, *args)
+      if method.to_s =~ /^(\w+)\?$/
+        v = self.class.find_by_symbol($1)
+        raise NameError unless v
+        other = v.to_sym
+        self.class.class_eval { define_method(method) { self.to_sym == other }}
+        return self.to_sym == other
+      end
+      super
+    end
+
+    def respond_to?(meth, include_private = false) # :nodoc
+      if m = /^(\w+)\?$/.match(meth.to_s)
+        return true if self.to_sym == m[1].to_sym
+      end
+      super
+    end
+    
+    # Flushes cache if record is saved
+    def flush_cache
+      Rails.cache.delete([self.class.name, symbol_was.to_s])
+      Rails.cache.delete([self.class.name, id])
+    end
+  end
+end

data/lib/domain_neutral/version.rb

@@ -0,0 +1,3 @@
+module DomainNeutral
+  VERSION = "1.0.0"
+end

data/lib/domain_neutral.rb

@@ -0,0 +1,18 @@
+require 'domain_neutral/symbolized_class'
+require "domain_neutral/engine"
+require 'domain_neutral/railtie' if defined?(Rails)
+require 'domain_neutral/association'
+module DomainNeutral
+  mattr_accessor :seed_options
+  # Identifies the Rails generation version
+  # Rails.version "4.2.1"
+  # => 4
+  def self.rails_generation
+    @@__generation ||= Rails.version.split('.')[0].to_i
+  end
+  
+  def self.seed
+    require 'domain_neutral/seed'
+    Seed.new
+  end
+end

data/lib/tasks/domain_neutral_tasks.rake

@@ -0,0 +1,10 @@
+namespace :domain_neutral do
+  namespace :seed do
+    desc 'Seed descriptors directly without migration'
+    task :descriptors => :environment do
+      require 'domain_neutral/seeder/descriptors'
+      DomainNeutral::Seeder::Descriptors.seed self 
+    end
+  end
+end
+