meta_vars 1.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in meta_vars.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/class_level_inheritable_attributes.rb

@@ -0,0 +1,31 @@
+# This code was proudly and shamelessly copied from
+# http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/
+# so let's all thank John Nunemaker with a loud and strong applause: PLAS!!!!'
+
+module MetaVars
+  module ClassLevelInheritableAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inheritable_attributes(*args)
+        @meta_vars_inheritable_attributes ||= [:meta_vars_inheritable_attributes]
+        @meta_vars_inheritable_attributes += args
+        args.each do |arg|
+          class_eval %(
+            class << self; attr_accessor :#{arg} end
+          )
+        end
+        @meta_vars_inheritable_attributes
+      end
+
+      def inherited(subclass)
+        @meta_vars_inheritable_attributes.each do |inheritable_attribute|
+          instance_var = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+        end
+      end
+    end
+  end
+end

data/lib/meta_vars/meta_container.rb

@@ -0,0 +1,65 @@
+module MetaVars
+  class MetaContainer
+
+    attr_reader :collection
+    
+    def initialize
+      @collection = {}
+    end
+
+    def add(meta_var, namespace)
+      if namespace.nil?
+        @collection[meta_var.name.to_s] = meta_var
+      else
+        current_level, tail = namespace.split('.', 2)
+        @collection[current_level.to_s] ||= MetaContainer.new
+        @collection[current_level.to_s].add(meta_var, tail)
+      end
+    end
+
+    def find(namespace)
+      current_level, tail = namespace.split('.', 2)
+      if tail.nil?
+        @collection[current_level.to_s]
+      else
+        @collection[current_level.to_s].present? ? @collection[current_level.to_s].find(tail) : nil
+      end
+    end
+
+    def meta_vars
+      @collection.keys.inject([]) do |a,k|
+        case @collection[k]
+          when MetaVars::MetaContainer
+            a += @collection[k].meta_vars
+          when MetaVars::MetaVar
+            a << @collection[k]
+        end
+        a
+      end
+    end
+
+    def vars(env)
+      @collection.keys.inject([]) do |a,k|
+        case @collection[k]
+          when MetaVars::MetaContainer
+            a += @collection[k].vars(env)
+          when MetaVars::MetaVar
+            a << @collection[k].to_var(env)
+        end
+      end
+    end
+
+    def to_hash
+      @collection.keys.inject({}) do |h,k|
+        if @collection[k].is_a?(MetaVars::MetaContainer)
+          h[k] = @collection[k].to_hash
+        else
+          h[k] = @collection[k]
+        end
+        h
+      end
+    end
+
+  end
+
+end

data/lib/meta_vars/meta_var.rb

@@ -0,0 +1,25 @@
+module MetaVars
+  class MetaVar
+
+    attr_accessor :name, :proc
+    attr_reader :cache_key, :expires_in
+
+    def initialize(name, options = {}, &block)
+      @name = name
+      @proc = block
+      @cache_key = options[:cache_key] || "meta_vars/#{name}"
+      @expires_in = options[:expires_in] || 0
+    end
+
+    def to_var(contxt)
+
+      if @expires_in > 0
+        Rails.cache.fetch(@cache_key, :expires_in => @expires_in) do
+          MetaVars::Var.new(name, contxt.instance_eval(&proc))
+        end
+      else
+        MetaVars::Var.new(name, contxt.instance_eval(&proc))
+      end
+    end
+  end
+end

data/lib/meta_vars/var.rb

@@ -0,0 +1,11 @@
+module MetaVars
+  class Var
+
+    attr_accessor :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  end
+end

data/lib/meta_vars/version.rb

@@ -0,0 +1,3 @@
+module MetaVars
+  VERSION = "1.0.1"
+end

data/lib/meta_vars.rb

@@ -0,0 +1,80 @@
+require 'meta_vars/version'
+require 'class_level_inheritable_attributes'
+require 'meta_vars/var'
+require 'meta_vars/meta_var'
+require 'meta_vars/meta_container'
+
+module MetaVars
+  def self.included(base)
+    base.send(:include, MetaVars::ClassLevelInheritableAttributes)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def has_meta_var(name, options = {})
+
+      default_namespace = (options[:default_namespace])
+      method_name = name.to_s.singularize
+      container_name = "#{name.to_s.pluralize}_container"
+      inheritable = options[:inheritable]
+
+      meta_programming = %Q(
+        @#{container_name} = MetaVars::MetaContainer.new
+        @default_#{method_name}_namespace = '#{default_namespace}'
+
+        inheritable_attributes :#{container_name}, :default_#{method_name}_namespace if #{inheritable}.present?
+
+        class << self
+
+          attr_reader :#{container_name}
+          attr_accessor :default_#{method_name}_namespace
+
+          def #{method_name}(var_name, *namespaces, &block)
+            namespaces = ['#{default_namespace}'] if namespaces.empty?
+            namespaces.each do |namespace|
+              @#{container_name}.add(MetaVars::MetaVar.new(var_name, &block), namespace)
+            end
+          end
+
+          def find_meta_#{method_name}(var_name, namespace='#{default_namespace}')
+            @#{container_name}.find([namespace,var_name].join('.'))
+          end
+
+        end
+
+        def meta_#{method_name.pluralize}
+          #{container_name}.meta_vars
+        end
+
+        def find_meta_#{method_name.pluralize}(namespace = '#{default_namespace}')
+          #{container_name}.find(namespace).try(:meta_vars) || []
+        end
+
+        def find_meta_#{method_name}(var_name, namespace = '#{default_namespace}')
+          #{container_name}.find([namespace, var_name].join('.'))
+        end
+
+        def #{method_name.pluralize}(contxt)
+          #{container_name}.vars(contxt)
+        end
+
+        def find_#{method_name}(contxt, var_name, namespace = '#{default_namespace}')
+          #{container_name}.find([namespace, var_name].join('.')).try(:to_var,contxt)
+        end
+
+        def find_#{method_name.pluralize}(contxt, namespace = '#{default_namespace}')
+          #{container_name}.find(namespace).try(:vars,contxt) || []
+        end
+
+        def #{container_name}
+          self.class.#{container_name}
+        end
+
+        def default_#{method_name}_namespace
+          self.class.default_#{method_name}_namespace
+        end
+      )
+      self.class_eval(meta_programming)
+    end
+  end
+end

data/meta_vars.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "meta_vars/version"
+
+Gem::Specification.new do |s|
+  s.name        = "meta_vars"
+  s.version     = MetaVars::VERSION
+  s.authors     = ["eLafo"]
+  s.email       = ["javierlafora@gmail.com"]
+  s.homepage    = "https://github.com/eLafo/meta_vars"
+  s.summary     = %q{Creates variables for an object, which their value depends on some context}
+  s.description = %q{Creates variables for an object, which their value depends on some context. These vars will be accessible by methods and will be contained in an instance var -a container}
+
+  s.rubyforge_project = "meta_vars"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: meta_vars
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- eLafo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-21 00:00:00 Z
+dependencies: []
+
+description: Creates variables for an object, which their value depends on some context. These vars will be accessible by methods and will be contained in an instance var -a container
+email: 
+- javierlafora@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/class_level_inheritable_attributes.rb
+- lib/meta_vars.rb
+- lib/meta_vars/meta_container.rb
+- lib/meta_vars/meta_var.rb
+- lib/meta_vars/var.rb
+- lib/meta_vars/version.rb
+- meta_vars.gemspec
+homepage: https://github.com/eLafo/meta_vars
+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: meta_vars
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Creates variables for an object, which their value depends on some context
+test_files: []
+