bogo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b544e3d18be2de80a851293f139ef363d3e2460
+  data.tar.gz: 2634b067067e337a84006f5583263cbb18399930
+SHA512:
+  metadata.gz: 7c2f47cfac15a3cbcb72bd8e4d74dc2e2954512f7c8b4afff66624133eb5dfc93afaf2c16db37278cb38e4ff375fd632c8f2ec63fba83403f924f17139133f4d
+  data.tar.gz: d5df748c23547d30bf5db35672c94bb489cfabbaf35125870a451e3c5dc6eb4e038358e7831deb0a7623d3706884e9ea312329acb281be7393bf36f86cf23bba

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+# Contributing
+
+## Branches
+
+### `master` branch
+
+The master branch is the current stable released version.
+
+### `develop` branch
+
+The develop branch is the current edge of development.
+
+## Pull requests
+
+* https://github.com/spox/bogo/pulls
+
+Please base all pull requests of the `develop` branch. Merges to
+`master` only occur through the `develop` branch. Pull requests
+based on `master` will likely be cherry picked.
+
+## Issues
+
+Need to report an issue? Use the github issues:
+
+* https://github.com/spox/bogo/issues

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2014 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,6 @@
+# Bogo
+
+A collection of libraries.
+
+## Info
+* Repository: https://github.com/spox/bogo

data/bogo.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'bogo/version'
+Gem::Specification.new do |s|
+  s.name = 'bogo'
+  s.version = Bogo::VERSION.version
+  s.summary = 'Helper libraries'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/spox/bogo'
+  s.description = 'Helper libraries'
+  s.require_path = 'lib'
+  s.license = 'Apache 2.0'
+  s.add_dependency 'hashie'
+  s.files = Dir['lib/**/*'] + %w(bogo.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
+end

data/lib/bogo.rb

@@ -0,0 +1,10 @@
+require 'bogo/version'
+
+module Bogo
+  autoload :AnimalStrings, 'bogo/animal_strings'
+  autoload :Lazy, 'bogo/lazy'
+  autoload :Memoization, 'bogo/memoization'
+  autoload :Smash, 'bogo/smash'
+end
+
+autoload :Smash, 'bogo/smash'

data/lib/bogo/animal_strings.rb

@@ -0,0 +1,24 @@
+require 'bogo'
+
+module Bogo
+  # Animal stylings on strings
+  module AnimalStrings
+
+    # Camel case string
+    # @param string [String]
+    # @return [String]
+    def camel(string)
+      string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
+    end
+
+    # Snake case (underscore) string
+    #
+    # @param string [String]
+    # @return [String]
+    def snake(string)
+      string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('-', '_').downcase
+    end
+
+  end
+
+end

data/lib/bogo/lazy.rb

@@ -0,0 +1,238 @@
+require 'bogo'
+require 'digest/sha2'
+
+module Bogo
+  # Adds functionality to facilitate laziness
+  module Lazy
+
+    # Instance methods for laziness
+    module InstanceMethods
+
+      # @return [Smash] argument hash
+      def data
+        unless(@data)
+          @data = Smash.new
+        end
+        @data
+      end
+
+      # @return [Smash] updated data
+      def dirty
+        unless(@dirty)
+          @dirty = Smash.new
+        end
+        @dirty
+      end
+
+      # @return [Smash] current data state
+      def attributes
+        data.merge(dirty)
+      end
+
+      # Create new instance
+      #
+      # @param args [Hash]
+      # @return [self]
+      def load_data(args={})
+        args = args.to_smash
+        @data = Smash.new
+        self.class.attributes.each do |name, options|
+          val = args[name]
+          if(options[:required] && !args.has_key?(name) && !options.has_key?(:default))
+            raise ArgumentError.new("Missing required option: `#{name}`")
+          end
+          if(val.nil? && !args.has_key?(name) && options[:default])
+            if(options[:default])
+              val = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+            end
+          end
+          if(args.has_key?(name) || val)
+            self.send("#{name}=", val)
+          end
+        end
+        self
+      end
+
+      # Identifies valid state and automatically
+      # merges dirty attributes into data, clears
+      # dirty attributes
+      #
+      # @return [self]
+      def valid_state
+        data.merge!(dirty)
+        dirty.clear
+        @_checksum = Digest::SHA256.hexdigest(MultiJson.dump(data))
+        self
+      end
+
+      # Model is dirty or specific attribute is dirty
+      #
+      # @param attr [String, Symbol] name of attribute
+      # @return [TrueClass, FalseClass] model or attribute is dirty
+      def dirty?(attr=nil)
+        if(attr)
+          dirty.has_key?(attr)
+        else
+          if(@_checksum)
+            !dirty.empty? ||
+              @_checksum != Digest::SHA256.hexdigest(MultiJson.dump(data))
+          else
+            true
+          end
+        end
+      end
+
+      # @return [String]
+      def to_s
+        "<#{self.class.name}:#{object_id}>"
+      end
+
+      # @return [String]
+      def inspect
+        "<#{self.class.name}:#{object_id} [#{data.inspect}]>"
+      end
+
+    end
+
+    # Class methods for laziness
+    module ClassMethods
+
+      # Add new attributes to class
+      #
+      # @param name [String]
+      # @param type [Class, Array<Class>]
+      # @param options [Hash]
+      # @option options [TrueClass, FalseClass] :required must be provided on initialization
+      # @option options [Object, Proc] :default default value
+      # @option options [Proc] :coerce
+      # @return [nil]
+      def attribute(name, type, options={})
+        name = name.to_sym
+        options = options.to_smash
+        attributes[name] = Smash.new(:type => type).merge(options)
+        coerce = attributes[name][:coerce]
+        valid_types = [attributes[name][:type], NilClass].flatten.compact
+        allowed_values = attributes[name][:allowed]
+        multiple_values = attributes[name][:multiple]
+        depends_on = attributes[name][:depends]
+        define_method(name) do
+          send(depends_on) if depends_on
+          self.class.on_missing(self) unless data.has_key?(name) || dirty.has_key?(name)
+          dirty[name] || data[name]
+        end
+        define_method("#{name}=") do |val|
+          values = multiple_values && val.is_a?(Array) ? val : [val]
+          values.map! do |item|
+            valid_type = valid_types.detect do |klass|
+              item.is_a?(klass)
+            end
+            if(coerce && !valid_type)
+              item = coerce.arity == 2 ? coerce.call(item, self) : coerce.call(item)
+            end
+            valid_type = valid_types.detect do |klass|
+              item.is_a?(klass)
+            end
+            unless(valid_type)
+              raise TypeError.new("Invalid type for `#{name}` (#{item} <#{item.class}>). Valid - #{valid_types.map(&:to_s).join(',')}")
+            end
+            if(allowed_values)
+              unless(allowed_values.include?(item))
+                raise ArgumentError.new("Invalid value provided for `#{name}` (#{item.inspect}). Allowed - #{allowed_values.map(&:inspect).join(', ')}")
+              end
+            end
+            item
+          end
+          if(!multiple_values && !val.is_a?(Array))
+            dirty[name] = values.first
+          else
+            dirty[name] = values
+          end
+        end
+        define_method("#{name}?") do
+          send(depends_on) if depends_on
+          self.class.on_missing(self) unless data.has_key?(name)
+          !!data[name]
+        end
+        nil
+      end
+
+      # Return attributes
+      #
+      # @param args [Symbol] :required or :optional
+      # @return [Array<Hash>]
+      def attributes(*args)
+        @attributes ||= Smash.new
+        if(args.include?(:required))
+          Smash[@attributes.find_all{|k,v| v[:required]}]
+        elsif(args.include?(:optional))
+          Smash[@attributes.find_all{|k,v| !v[:required]}]
+        else
+          @attributes
+        end
+      end
+
+      # Instance method to call on missing attribute or
+      # object to call method on if set
+      #
+      # @param param [Symbol, Object]
+      # @return [Symbol]
+      def on_missing(param=nil)
+        if(param)
+          if(param.is_a?(Symbol))
+            @missing_method = param
+          else
+            if(@missing_method && !@calling_on_missing)
+              @calling_on_missing = true
+              begin
+                param.send(@missing_method)
+              ensure
+                @calling_on_missing = false
+              end
+            end
+            @missing_method
+          end
+        else
+          @missing_method
+        end
+      end
+
+      # Directly set attribute hash
+      #
+      # @param attrs [Hash]
+      # @return [TrueClass]
+      # @todo need deep dup here
+      def set_attributes(attrs)
+        @attributes = attrs.to_smash
+        true
+      end
+
+    end
+
+    class << self
+
+      # Injects laziness into class
+      #
+      # @param klass [Class]
+      def included(klass)
+        klass.class_eval do
+          include InstanceMethods
+          extend ClassMethods
+
+          class << self
+
+            def inherited(klass)
+              klass.set_attributes(
+                MultiJson.load(
+                  MultiJson.dump(self.attributes)
+                ).to_smash
+              )
+            end
+
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/bogo/memoization.rb

@@ -0,0 +1,53 @@
+require 'bogo'
+
+module Bogo
+  # Memoization helpers
+  module Memoization
+
+    # Memoize data
+    #
+    # @param key [String, Symbol] identifier for data
+    # @param direct [Truthy, Falsey] direct skips key prepend of object id
+    # @yield block to create data
+    # @yieldreturn data to memoize
+    # @return [Object] data
+    def memoize(key, direct=false)
+      unless(direct)
+        key = "#{self.object_id}_#{key}"
+      end
+      unless(_memo.has_key?(key))
+        _memo[key] = yield
+      end
+      _memo[key]
+    end
+
+    def _memo
+      Thread.current[:bogo_memoization] ||= Smash.new
+    end
+
+    # Remove memoized value
+    #
+    # @param key [String, Symbol] identifier for data
+    # @param direct [Truthy, Falsey] direct skips key prepend of object id
+    # @return [NilClass]
+    def unmemoize(key, direct=false)
+      unless(direct)
+        key = "#{self.object_id}_#{key}"
+      end
+      _memo.delete(key)
+    end
+
+    # Remove all memoized values
+    #
+    # @return [TrueClass]
+    def clear_memoizations!
+      _memo.keys.find_all do |key|
+        key.to_s.start_with?("#{self.object_id}_")
+      end.each do |key|
+        _memo.delete(key)
+      end
+      true
+    end
+
+  end
+end

data/lib/bogo/smash.rb

@@ -0,0 +1,151 @@
+require 'hashie'
+require 'digest/sha2'
+require 'bogo'
+
+module Bogo
+
+  # Customized Hash
+  class Smash < Hash
+    include Hashie::Extensions::IndifferentAccess
+    include Hashie::Extensions::MergeInitializer
+    include Hashie::Extensions::DeepMerge
+    include Hashie::Extensions::Coercion
+
+    coerce_value Hash, Smash
+
+    # Create new instance
+    #
+    # @param args [Object] argument list
+    def initialize(*args)
+      base = nil
+      if(args.first.is_a?(::Hash))
+        base = args.shift
+      end
+      super *args
+      if(base)
+        self.replace(base.to_smash)
+      end
+    end
+
+    def merge!(hash)
+      hash = hash.to_smash
+      super(hash)
+    end
+
+    # Get value at given path
+    #
+    # @param args [String, Symbol] key path to walk
+    # @return [Object, NilClass]
+    def retrieve(*args)
+      args.inject(self) do |memo, key|
+        if(memo.is_a?(Hash))
+          memo.to_smash[key]
+        else
+          nil
+        end
+      end
+    end
+    alias_method :get, :retrieve
+
+    # Fetch value at given path or return a default value
+    #
+    # @param args [String, Symbol, Object] key path to walk. last value default to return
+    # @return [Object] value at key or default value
+    def fetch(*args)
+      default_value = args.pop
+      retrieve(*args) || default_value
+    end
+
+    # Set value at given path
+    #
+    # @param args [String, Symbol, Object] key path to walk. set last value to given path
+    # @return [Object] value set
+    def set(*args)
+      unless(args.size > 1)
+        raise ArgumentError.new 'Set requires at least one key and a value'
+      end
+      value = args.pop
+      set_key = args.pop
+      leaf = args.inject(self) do |memo, key|
+        unless(memo[key].is_a?(Hash))
+          memo[key] = Smash.new
+        end
+        memo[key]
+      end
+      leaf[set_key] = value
+      value
+    end
+
+    # Convert to Hash
+    #
+    # @return [Hash]
+    def to_hash(*args)
+      self.to_type_converter(::Hash, :to_hash, *args)
+    end
+
+    # Calculate checksum of hash (sha256)
+    #
+    # @return [String] checksum
+    def checksum
+      Digest::SHA256.hexdigest(self.to_smash(:sorted).to_s)
+    end
+
+  end
+end
+
+# Hook helper into toplevel `Hash`
+class Hash
+
+  # Convert to Smash
+  #
+  # @return [Smash]
+  def to_smash(*args)
+    self.to_type_converter(::Smash, :to_smash, *args)
+  end
+  alias_method :hulk_smash, :to_smash
+
+  protected
+
+  # Convert to type
+  #
+  # @param type [Class] hash type
+  # @param convert_call [Symbol] builtin hash convert
+  # @return [Smash]
+  def to_type_converter(type, convert_call, *args)
+    type.new.tap do |smash|
+      if(args.include?(:sorted))
+        process = self.sort_by do |entry|
+          entry.first.to_s
+        end
+      else
+        process = self
+      end
+      process.each do |k,v|
+        smash[k.is_a?(Symbol) ? k.to_s : k] = smash_conversion(v, convert_call, *args)
+      end
+    end
+  end
+
+  # Convert object to smash if applicable
+  #
+  # @param obj [Object]
+  # @param convert_call [Symbol] builtin hash convert
+  # @return [Smash, Object]
+  def smash_conversion(obj, convert_call, *args)
+    case obj
+    when Hash
+      obj.send(convert_call, *args)
+    when Array
+      obj.map do |i|
+        smash_conversion(i, convert_call, *args)
+      end
+    else
+      obj
+    end
+  end
+
+end
+
+unless(defined?(Smash))
+  Smash = Bogo::Smash
+end

data/lib/bogo/version.rb

@@ -0,0 +1,4 @@
+module Bogo
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: bogo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Helper libraries
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- bogo.gemspec
+- lib/bogo.rb
+- lib/bogo/animal_strings.rb
+- lib/bogo/lazy.rb
+- lib/bogo/memoization.rb
+- lib/bogo/smash.rb
+- lib/bogo/version.rb
+homepage: https://github.com/spox/bogo
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Helper libraries
+test_files: []
+has_rdoc: