tinkit 0.0.0

data/lib/helpers/camel.rb

@@ -0,0 +1,21 @@
+#copy of Rails camelize and underscore (almost)
+
+module Camel
+  def self.ize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+  
+  def self.score(camel_cased_word)
+     word = camel_cased_word.to_s.dup
+     word.gsub!(/::/, '_')  #except I changed '/' to '_'
+     word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+     word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+     word.tr!("-", "_")
+     word.downcase!
+     word
+  end
+end

data/lib/helpers/filesystem_helpers.rb

@@ -0,0 +1,27 @@
+
+class DirFilter
+  def initialize(ignore_list)
+    @ignore_list = [ignore_list].flatten
+    @ignore_list << /^\./    #ignore dot files
+  end
+  
+  
+  def filter_entries(path)
+    wkg_entries = Dir.entries(path)
+    #remove dot files
+    wkg_entires = wkg_entries.delete_if{|entry| in_ignore_list?(entry)  }
+  end
+  
+  private
+  def in_ignore_list?(entry)
+    in_ignore = @ignore_list.map{|list| true if entry =~ list}
+    in_ignore.compact.first  #nil if nothing in ignore
+  end
+end
+
+class FileNames
+  def flatten_problem_chars(filenames)
+    #via http://stackoverflow.com/questions/2270635/invalid-chars-filter-for-file-folder-name-ruby
+    file_names.map! { |f| f.gsub(/[\x00\/\\:\*\?\"<>\|]/, '_') }
+  end
+end

data/lib/helpers/hash_helpers.rb

@@ -0,0 +1,74 @@
+require 'ostruct'
+
+   #from Facets via Hashery
+class Hash
+  
+
+
+  def rekey!(*args, &block)
+    # for backward comptability (TODO: DEPRECATE).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k.to_sym} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk]=delete(k) if nk
+      end
+    else
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = self.delete(from) if self.has_key?(from)
+    end
+    self
+  end
+  
+  def rekey(*args, &block)
+     dup.rekey!(*args, &block)
+   end
+   
+  public :rekey, :rekey!
+end
+
+module HashKeys
+  def self.str_to_sym(a_hash)
+    raise "#{a_hash.class.name} must respond to inject" unless a_hash.respond_to? :inject
+    a_hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+  end
+ 
+  def self.sym_to_str(a_hash) #inverse of above
+    raise "#{a_hash.class.name} must respond to inject" unless a_hash.respond_to? :inject
+    a_hash.inject({}){|memo,(k,v)| memo["#{k}"] = v; memo}
+  end
+end
+
+module HashOps
+  def self.remove_hash(other_hash)
+    delete_if { |k,v| other_hash[k] == v }
+  end
+end
+
+class MoreOpenStruct < OpenStruct
+  def _to_hash
+    h = @table
+    #handles nested structures
+    h.each do |k,v|
+      if v.class == MoreOpenStruct
+        h[k] = v._to_hash
+      end
+    end
+    return h
+  end
+  
+  def _table
+    @table   #table is the hash structure used in OpenStruct
+  end
+  
+  def _manual_set(hash)
+    if hash && (hash.class == Hash)
+      for k,v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+end

data/lib/helpers/log_helper.rb

@@ -0,0 +1,34 @@
+require 'log4r'
+
+#Set Logger
+#TODO: Create spec
+module TinkitLog
+  include Log4r
+
+  class << self; attr_accessor :default_level, :fatal_log, :log_output end
+  TinkitLog.default_level = :info
+  TinkitLog.log_output = 'stdout'
+  TinkitLog.fatal_log = Logger.new('fatal_log')
+  TinkitLog.fatal_log.level = FATAL
+  TinkitLog.fatal_log.outputters = Outputter[TinkitLog.log_output]
+
+  @@log_levels = { :debug => DEBUG,
+                   :info => INFO,
+                   :warn => WARN,
+                   :error => ERROR,
+                   :fatal => FATAL
+                 }
+
+  def self.set(name, level=TinkitLog.default_level, out=Outputter.stdout)
+    log = Logger[name] || Logger.new(name)
+    log.outputters = out
+    log.level = @@log_levels[level]
+    log.trace = true if log.level <= DEBUG
+    log
+  end
+
+  def self.log_raise(error_msg, exc_type= RuntimeError)
+    self.fatal_log.fatal("#{__LINE__} #{error_msg}") 
+    raise exc_type, error_msg
+  end
+end

data/lib/helpers/mime_types_new.rb

@@ -0,0 +1,126 @@
+#Copyright (C) 2010  David Martin
+#
+#David Martin mailto:dmarti21@gmail.com
+  
+
+require 'mime/types'
+
+#This class will include the Office 2007 extension types when looking up MIME types.
+class MimeNew
+
+  DefaultUnknownContentType = "application/octet-stream"
+  #Returns the mime type of a file
+  #  MimeNew.for_ofc_x('a_new_word_doc.docx') 
+  #  #=>  "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  def self.for_ofc_x(fname)
+    cont_type = nil
+    old_ext = File.extname(fname)
+    cont_type =case old_ext
+      #New Office Formats
+    when '.docx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"]
+    when '.dotx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.template"]
+    when '.pptx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.presentation"]
+    when '.ppsx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.slideshow"]
+    when '.potx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.template"]
+    when '.xlsx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"]
+    when '.xltx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.template"]
+    else
+      self.other_content_types(fname)
+    end#case
+    cont_type = [cont_type].flatten.first
+    #puts "Content Type returned: #{cont_type.inspect}"
+    return cont_type
+  end# def
+
+  def self.just_ofc_x(ext)
+    cont_type = case File.extname(fname)
+      #New Office Formats
+    when '.docx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"]
+    when '.dotx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.template"]
+    when '.pptx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.presentation"]
+    when '.ppsx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.slideshow"]
+    when '.potx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.template"]
+    when '.xlsx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"]
+    when '.xltx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.template"]
+    end
+  end
+  
+  def self.other_content_types(fname)
+    std_type = MIME::Types.type_for(fname).first
+    rtn = if std_type
+      std_type.content_type
+    else
+      DefaultUnknownContentType
+    end
+    return rtn
+  end#def
+end
+
+
+#duck punching RestClient's duck punch for bufs because libraries are using MIME::Types directly
+=begin
+module MIME
+  class Types
+
+    # Return the first found content-type for a value considered as an extension or the value itself
+    def type_for_extension ext
+      puts "Duck Punch ext: #{ext.inspect}"
+      candidates = @extension_index[ext] 
+      puts "Duck Punch candidates: #{candidates.inspect}"
+      candidates.empty? ? ext : candidates[0].content_type
+    end
+  end
+end
+=end
+=begin
+class MIME::Types
+  def type_for(filename, platform = false)
+    puts "Duck Punched MIME::Types"
+    puts "--filename: #{filename.inspect}"
+
+      ext = filename.chomp.downcase.gsub(/.*\./o, '')
+      list = @extension_index[ext]
+      list.delete_if { |e| not e.platform? } if platform
+      list
+      
+      new_ext = File.extname(filename)
+    cont_type =case new_ext
+      #New Office Formats
+    when '.docx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"]
+    when '.dotx'
+      ["application/vnd.openxmlformats-officedocument.wordprocessingml.template"]
+    when '.pptx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.presentation"]
+    when '.ppsx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.slideshow"]
+    when '.potx'
+      ["application/vnd.openxmlformats-officedocument.presentationml.template"]
+    when '.xlsx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"]
+    when '.xltx'
+      ["application/vnd.openxmlformats-officedocument.spreadsheetml.template"]
+    end
+   
+    puts "Duck New Cont Type: #{cont_type.inspect}" 
+    (list + cont_type).compact! if cont_type
+    puts "Duck Mime Extension: #{ext.inspect}"
+    puts "Duck Content Types: #{ list.map{|m| m.content_type} }"
+    list
+  end
+end
+=end

data/lib/helpers/old_more_open_struct.rb

@@ -0,0 +1,28 @@
+require 'ostruct'
+
+class MoreOpenStruct < OpenStruct
+  def _to_hash
+    h = @table
+    #handles nested structures
+    h.each do |k,v|
+      if v.class == MoreOpenStruct
+        h[k] = v._to_hash
+      end
+    end
+    return h
+  end
+  
+  def _table
+    @table   #table is the hash structure used in OpenStruct
+  end
+  
+  def _manual_set(hash)
+    if hash && (hash.class == Hash)
+      for k,v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+end
+

data/lib/helpers/require_helper.rb

@@ -0,0 +1,45 @@
+#Tinkit Library Locations
+module Tinkit
+  @@top = File.join(File.dirname(__FILE__), '../..')  #main bufs directory
+  @@lib = File.join(@@top, 'lib/')
+  @@helpers = File.join(@@top, 'lib/helpers/')
+  @@moabs = File.join(@@lib, 'moabs')
+  @@midas = File.join(@@lib, 'midas')
+  @@glue = File.join(@@lib, 'glue_envs')
+  @@specs = File.join(@@top, 'spec')
+  @@spec_helpers = File.join(@@specs, 'helpers')
+  @@fixtures = File.join(@@top, 'bufs_fixtures')
+
+  def self.lib(req_file)
+    File.expand_path(File.join(@@lib, req_file))
+  end
+
+  def self.helpers(req_file)
+    File.expand_path(File.join(@@helpers, req_file))
+  end
+
+  def self.spec(req_file)
+    File.expand_path(File.join(@@specs, req_file))
+  end
+
+  def self.spec_helpers(req_file)
+    File.expand_path(File.join(@@spec_helpers, req_file))
+  end
+
+  def self.fixtures(req_file)
+    File.expand_path(File.join(@@fixtures, req_file))
+  end
+
+  def self.moabs(req_file)
+    File.expand_path(File.join(@@moabs, req_file))
+  end
+
+  def self.midas(req_file)
+    File.expand_path(File.join(@@midas, req_file))
+  end
+
+  def self.glue(req_file)
+    File.expand_path(File.join(@@glue, req_file))
+  end
+end
+

data/lib/helpers/tk_escape.rb

@@ -0,0 +1,17 @@
+require 'cgi'  #Can replace with url_escape if performance is an issue
+
+class TkEscape
+  def self.escape(str)
+    esc_str = str.gsub(/([^a-zA-Z0-9_.-]+)/n, '_')
+    #str.gsub!('+', ' ')
+    #str = CGI.escape(str)
+    #str.gsub!('%2B', '+')
+    return esc_str
+  end
+
+  #TODO: Continue using cgi or create unescape specific to Tinkit?
+  def self.unescape(str)
+    return CGI.unescape(str)
+  end
+end
+

data/lib/midas/bufs_data_structure.rb

@@ -0,0 +1,84 @@
+module DataStructureModels
+  module Tinkit
+    #Required Keys on instantiation
+    RequiredInstanceKeys = [:my_category]
+    RequiredSaveKeys = [:my_category]  #duplicative?
+    NodeKey = :my_category #TODO look at supporting multiple node keys
+  end
+end
+
+=begin
+module NodeElementOperations
+  #TODO the hash inside the proc is confusing (the curly braces) update to better readability
+  MyCategoryAddOp = lambda {|this,other|   Hash[:update_this => this]  } #my cat is not allowed to change
+  MyCategorySubtractOp = lambda{ |this, other| Hash[:update_this => this] } #TODO use this to delete a node?
+  MyCategoryOps = {:add => MyCategoryAddOp, :subtract => MyCategorySubtractOp}
+  ParentCategoryAddOp = lambda {|this,other|
+                           this = this || []
+                           other = other || []
+                           this = this + [other].flatten
+                           this.uniq!; this.compact!
+                           Hash[:update_this => this]
+                         }
+  ParentCategorySubtractOp = lambda {|this,other| 
+                                this = [this] || []
+                                other = [other] || []
+                                this.flatten!
+                                other.flatten!
+                                this -= other
+                                this.uniq!
+                                this.compact!
+                                Hash[:update_this => this]
+                               }
+  ParentCategoryOps = {:add => ParentCategoryAddOp, :subtract => ParentCategorySubtractOp}
+  LinkAddOp = lambda {|this, other|
+                                 this = this || {}  #investigate why its passed as nil (probably hasn't been built yet
+                                 other = other || {}
+                                 srcs = other.keys
+                                 srcs.each {|s| if this[s]
+                                            #this[s] = [ other[s] ].flatten
+                                            this[s] = other[s]
+                                           else
+                                            #this[s] = [ other[s] ].flatten
+                                            this[s] = other[s]
+                                           end }
+                                           #this[s].uniq!
+                                           #this[s].compact! }
+                           Hash[:update_this => this] }
+  #if link_name is used besides other, then all link_names would need to be unique, so we use other
+  LinkSubtractOp = lambda {|this, other| this = this || {}
+                                          #Hacked together needs thought out (and TESTED!!)
+                                         other = other || {}
+                                         puts "This / Other: #{this.inspect} / #{other.inspect}"
+                                         #srcs = [other].flatten
+                                         other.keys.each { |s|
+                                                      #other[s].each {|olnk| this[s].delete(olnk) if this[s]}
+                                                      puts "delete #{other[s].inspect} from #{this[s].inspect}"
+                                                      #this[s].delete(other[s]) if this[s]
+                                                      this.delete(s) 
+                                                      #this.delete(s) if (this[s].nil? || this[s].empty?)
+                                              }
+                                         Hash[:update_this => this]
+                           }
+  #think if this is what you want, returning a single uri if only one exists, while an array if more than one?
+  #I think so since it's *almost* an error case if more than one url exists for a name, but I'm not sure this is the best approach
+  LinkGetOp = lambda {|this, link_name|
+                                       this_ary = this.to_a
+                                       rtn_val = nil
+                                       rtn_val = if this_ary.flatten.include? link_name
+                                         srcs = []
+                                         this_ary.each { |s, ls| srcs << s if ls.include? link_name }
+                                         rtn_val =  {:return_value => srcs, :update_this => this } if srcs.size > 1
+                                         rtn_val = {:return_value => srcs.first, :update_this => this } if srcs.size == 1
+                                         rtn_val
+                                        else
+                                          rtn_val = {:return_value => nil, :update_this => this} 
+                                        end
+                                        rtn_val
+                     }
+
+  LinkOps = {:add => LinkAddOp, :subtract => LinkSubtractOp, :get => LinkGetOp}
+
+  Ops = {:my_category => MyCategoryOps, :parent_categories => ParentCategoryOps, :links => LinkOps}
+end
+=end