foxy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 023199508c4795ba3684051b2e66b867c3827402
+  data.tar.gz: adaa60aee3b7c730730cb004c8305283d29fdd40
+SHA512:
+  metadata.gz: a5a89839425f54a1ebec774b9acdf38b75fa090832af905e7739387ad7ca75ec9ce1c9336064a68c9f305e4fa3b28626f067a51207ac823c1bb2c91d24eb2fb4
+  data.tar.gz: 6c814a1fd26e59b05eb37f338a8d26ce9c719f94b45b0a400e3961e989c3f8e7ac808fb99d685cd4d029aaa6c6dc89095eedf00a3941d37487299d6732042952

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Documentation:
+  Enabled: false
+Style/AsciiComments:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+LineLength:
+  Max: 100

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Manuel Albarrán
+
+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/README.md

@@ -0,0 +1,52 @@
+# Foxy
+
+A set of `Foxy` tools for make easy retrieve information for another servers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'foxy', :git => 'git://github.com/weapp/foxyrb.git'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+```ruby
+require "foxy"
+require "pp"
+
+response = Foxy::Client.new.eraw(path: "https://www.w3.org/")
+
+puts
+puts "Example1"
+puts "Way 1:"
+results = response.foxy.search(cls: "info-wrap")
+results.each do |result|
+    pp(summary: result.find(cls: "summary").try(:joinedtexts),
+       source: result.find(cls: "source").try(:joinedtexts),
+       where: result.find(cls: "location").try(:joinedtexts))
+end
+
+puts "Way 2:"
+results = response.foxy.css(".info-wrap")
+results.each do |result|
+    pp(summary: result.css(".summary").first.try(:joinedtexts),
+       source: result.css(".source").first.try(:joinedtexts),
+       where: result.css(".location").first.try(:joinedtexts))
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/weapp/foxy.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "foxy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/foxy.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'foxy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "foxy"
+  spec.version       = Foxy::VERSION
+  spec.authors       = ["Manuel Albarrán"]
+  spec.email         = ["weap88@gmail.com"]
+
+  spec.summary       = %q{Foxy tools for foxy things.}
+  spec.description   = %q{A set of foxy tools for make easy retrieve information for another servers.}
+  spec.homepage      = "https://github.com/weapp/foxyrb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 0.9.2"
+  spec.add_dependency "faraday_middleware", "~> 0.10.0"
+  spec.add_dependency "patron", "~> 0.6.1"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/foxy.rb

@@ -0,0 +1,29 @@
+require "foxy/version"
+require "foxy/client"
+require "foxy/html"
+require "foxy/repository"
+
+module Foxy
+  class << self
+    attr_accessor :env
+  end
+
+  RE_HTML = %r{
+  (</[a-zA-Z]+[^>]*>)                 #closetag
+  |(<[a-zA-Z]+(?:[^/>]|/[^>])*/>)     #singletag
+  |(<[a-zA-Z]+[^>]*>)                 #tag
+  |([^<]+)                            #notag
+  |(<!--.*?-->)                       #|(<![^>]*>) #comment
+  |(.)                                #other}imx
+
+  RE_TAG = /<([a-zA-Z]+[0-9]*)/m
+  RE_TAG_ID = /id=(("[^"]*")|('[^']*')|[^\s>]+)/m
+  RE_TAG_CLS = /class=(("[^"]*")|('[^']*')|[^\s>]+)/m
+  RE_CLOSETAG = %r{</([a-zA-Z]+[0-9]*)}m
+
+  SINGLES = %w(meta img link input area base col br hr).freeze
+  ALLOW = %w(alt src href title).freeze
+  INLINE_TAGS = %w(a abbr acronym b br code em font i
+                   img ins kbd map samp small span strong
+                   sub sup textarea).freeze
+end

data/lib/foxy/adverb.rb

@@ -0,0 +1,87 @@
+module Foxy
+  class Adverb
+    attr_accessor :value
+
+    def self.define(&block)
+      Class.new(self) { define_method(:and_then, &block) }
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    def and_then
+      yield value
+    end
+
+    def then(&block)
+      self.class.new(&block)
+    end
+
+    def tap(*args, &block)
+      method_missing(:tap, *args, &block)
+    end
+
+    def method_missing(m, *args, &block)
+      and_then { |instance| instance.public_send(m, *args, &block) }
+    end
+  end
+
+  Dangerously = Adverb.define do |&block|
+    block.call(value).tap { |result| fail "nil!" if result.nil? }
+  end
+
+  Optional = Adverb.define do |&block|
+    value.nil? ? nil : block.call(value)
+  end
+
+  Mapy = Adverb.define do |&block|
+    value.map { |v| block.call(v) }
+  end
+
+  Many = Adverb.define do |&block|
+    value.flat_map { |v| block.call(v) }
+  end
+
+  Safy = Adverb.define do |&block|
+    begin
+      block.call(value)
+    rescue
+      value
+    end
+  end
+
+  module Monads
+    def safy
+      Safy.new(self)
+    end
+
+    def optionaly
+      Optional.new(self)
+    end
+
+    def mapy
+      Mapy.new(self)
+    end
+
+    def many
+      Many.new(self)
+    end
+
+    def dangerously
+      Dangerously.new(self)
+    end
+
+    def normally
+      Adverb.new(self)
+    end
+
+    def then
+      yield value
+    end
+
+    def and_then
+      self
+    end
+  end
+end

data/lib/foxy/client.rb

@@ -0,0 +1,79 @@
+require "json"
+require "faraday"
+require 'faraday_middleware'
+require "patron"
+
+require "foxy/extensions"
+require "foxy/rate_limit"
+require "foxy/file_cache"
+require "foxy/html_response"
+
+module Foxy
+  class Client
+    include RateLimit
+
+    attr_reader :conn, :config, :default_options
+
+    def initialize(config = {})
+      @config = config
+      @default_options = config.fetch(:default_options, {}).recursive_hash
+
+      @conn = Faraday.new(url: url) do |connection|
+        connection.options[:timeout] = config.fetch(:timeout, 120)
+        connection.options[:open_timeout] = config.fetch(:open_timeout, 20)
+        connection.headers[:user_agent] = user_agent
+
+        connection.use(Faraday::Response::Middleware)
+        # connection.response :logger
+        # connection.response :json
+        # connection.use FaradayMiddleware::Gzip
+        # connection.adapter(Faraday.default_adapter)
+        connection.adapter :patron
+      end
+    end
+
+    def user_agent
+      "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36"
+    end
+
+    def request(options)
+      wait!
+      opts = default_options.deep_merge(options)
+
+      conn.get(opts.fetch(:path), opts.fetch(:params, {}))
+    end
+
+    def json(options)
+      JSON[raw(options)]
+    end
+
+    def raw(options)
+      request(options).body
+    end
+
+    def eraw(options)
+      cacheopts = options.delete(:cache)
+      klass = options.delete(:class) || Foxy::HtmlResponse
+      response_options = options.merge(options.delete(:response_params) || {})
+      klass.new(raw_with_cache(options, cacheopts), response_options)
+    end
+
+    def url
+      "http://www.example.com"
+    end
+
+    def cache
+      @cache ||= FileCache.new(self.class.name.split("::").last.downcase)
+    end
+
+    def fixed(id, legth = 2, fill = "0")
+      id.to_s.rjust(legth, fill)
+    end
+
+    private
+
+    def raw_with_cache(options, cacheopts)
+      raw(options)
+    end
+  end
+end

data/lib/foxy/collection.rb

@@ -0,0 +1,70 @@
+require "delegate"
+
+module Foxy
+  class Collection < SimpleDelegator
+    include Monads
+
+    def attr(name)
+      each_with_object([]) { |node, acc| acc << node.attr(name) if node }
+    end
+
+    def search(**kws)
+      return search(parse_css(kws[:css])) if kws[:css]
+
+      filters = kws.delete(:filters)
+
+      Collection.new(flat_map { |node| node.search(**kws) }).tap do |r|
+        return filters.inject(r) { |_memo, filter| r.public_send(filter) } if filters
+      end
+    end
+
+    def css(query)
+      query.split(/\s+/).inject(self) { |memo, q| memo.search(css: q) }
+    end
+
+    def texts
+      map(&:texts).__getobj__
+    end
+
+    def joinedtexts
+      each_with_object([]) { |node, acc| acc << node.joinedtexts if node }
+    end
+
+    def map
+      self.class.new(super)
+    end
+
+    def flat_map
+      self.class.new(super)
+    end
+
+    def rebuild
+      map(&:to_s).__getobj__.join
+    end
+
+    def clean(*args)
+      mapy.clean(*args)
+    end
+
+    private
+
+    # assert Foxy::Html.new.parse_css("tag#id") == {tagname: "tag", id: "id"}
+    # assert Foxy::Html.new.parse_css("#id") == {id: "id"}
+    # assert Foxy::Html.new.parse_css("tag") == {tagname: "tag"}
+    # assert Foxy::Html.new.parse_css("tag.cls") == {tagname: "tag", cls: ["cls"]}
+    # assert Foxy::Html.new.parse_css(".class") == {cls: ["class"]}
+    # assert Foxy::Html.new.parse_css(".class.class") == {cls: ["class", "class"]}
+    # assert Foxy::Html.new.parse_css(".cls.class") == {cls: ["cls", "class"]}
+    def parse_css(css)
+      token = "([^:#\.\s]+)"
+      css
+        .scan(/#{token}|##{token}|\.#{token}|:#{token}/)
+        .each_with_object({}) do |(tagname, id, cls, filter), memo|
+          next memo[:tagname] = tagname if tagname
+          next memo[:id] = id if id
+          memo.fetch(:filters) { memo[:filters] = [] } << filter if filter
+          memo.fetch(:cls) { memo[:cls] = [] } << cls if cls
+        end
+    end
+  end
+end

data/lib/foxy/extensions.rb

@@ -0,0 +1,60 @@
+require "foxy/adverb"
+
+class Object
+  def deep_symbolize_keys
+    self
+  end
+
+  def try(m, *a, &b)
+    public_send(m, *a, &b) if respond_to?(m)
+  end
+end
+
+class Hash
+  def deep_symbolize_keys
+    symbolize_keys.tap { |h| h.each { |k, v| h[k] = v.deep_symbolize_keys } }
+  end
+
+  def symbolize_keys
+    Hash[map { |k, v| [k.to_sym, v] }]
+  end
+
+  def deep_merge(second)
+    merger = proc { |_, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+    merge(second, &merger)
+  end
+
+  def recursive_hash
+    tap { self.default_proc = proc { |h, k| h[k] = Hash.new(&h.default_proc) } }
+  end
+
+  def slice(*keys)
+    Hash[keys.zip(values_at(*keys))]
+  end
+
+  def downcase_keys
+    each_with_object({}) { |(k, v), h| h.store(k.downcase, v) }
+  end
+end
+
+class Array
+  def deep_symbolize_keys
+    map(&:deep_symbolize_keys)
+  end
+
+  def mapy
+    Foxy::Mapy.new(self)
+  end
+end
+
+class NilClass
+  def try(*_args)
+    nil
+  end
+end
+
+class Enumerator::Yielder
+  def +(enum)
+    enum.each { |it| self << it }
+  end
+end

data/lib/foxy/file_cache.rb

@@ -0,0 +1,85 @@
+require "yaml"
+
+module Foxy
+  class FileCache
+    class << self
+      attr_accessor :nocache
+
+      def nocache!(reason = nil)
+        self.nocache = true
+        puts "NO CACHE: #{reason}"
+        binding.pry
+      end
+
+      def html(*path, &block)
+        cache path, "html", &block
+      end
+
+      def raw(*path, &block)
+        cache path, "txt", &block
+      end
+
+      def json(*path)
+        JSON[cache(path, "json") { JSON[yield] }]
+      end
+
+      def yaml(*path)
+        YAML.load(cache(path, "yaml") { YAML.dump(yield) })
+      end
+
+      def html!(*path, &block)
+        cache! path, "html", &block
+      end
+
+      def raw!(*path, &block)
+        cache! path, "txt", &block
+      end
+
+      def json!(*path)
+        JSON[cache!(path, "json") { JSON[yield] }]
+      end
+
+      def yaml!(*path)
+        YAML.load(cache!(path, "yaml") { YAML.dump(yield) })
+      end
+
+      private
+
+      def cache(path, format, force = false)
+        self.nocache = false
+        path_tokens = path.map { |slice| slice.to_s.gsub(/[^a-z0-9\-]+/i, "_") }
+                      .unshift("cache")
+        filepath = path_tokens.join("/") + ".#{format}"
+
+        return File.read(filepath) if File.exist?(filepath) && !force
+
+        makedir_p(path_tokens[0...-1])
+        res = yield.to_s
+        File.write(filepath, res) unless nocache
+
+        res
+      end
+
+      def cache!(path, format, &block)
+        cache(path, format, true, &block)
+      end
+
+      def makedir_p(tokens)
+        1.upto(tokens.size) do |n|
+          dir = tokens[0...n].join("/")
+          Dir.mkdir(dir) unless Dir.exist?(dir)
+        end
+      end
+    end
+
+    def initialize(*path)
+      @path = path
+    end
+
+    %i(html raw json yaml html! raw! json! yaml!).each do |format|
+      define_method(format) do |*path, &block|
+        self.class.send(format, *(@path + path), &block)
+      end
+    end
+  end
+end

data/lib/foxy/html.rb

@@ -0,0 +1,114 @@
+require "delegate"
+require "foxy/adverb"
+require "foxy/collection"
+require "foxy/node"
+
+module Foxy
+  class Html < SimpleDelegator
+    include Monads
+
+    def try(m, *a, &b)
+      public_send(m, *a, &b) if respond_to?(m)
+    end
+
+    def initialize(html = nil)
+      if html.nil?
+        super([])
+      elsif html.is_a? self.class
+        super(html.__getobj__)
+      elsif html.respond_to?(:to_str)
+        super(html.to_str.scan(RE_HTML).map { |args| Node.build(*args) })
+      elsif html.respond_to?(:read)
+        super(html.read.scan(RE_HTML).map { |args| Node.build(*args) })
+      else
+        super(html)
+      end
+    end
+
+    def clean(**kws)
+      Html.new(map { |node| node.clean(**kws) })
+    end
+
+    def isearch(tagname: nil, id: nil, cls: nil, fun: nil, css: nil)
+      cls = Array(cls)
+      tagname &&= tagname.downcase
+      y = 0
+      buff = []
+
+      close_tagname = nil
+      each do |node| # [1:-1]:
+        # El orden de los if es importante para que devuelva el
+        # primer y el ultimo nodo
+        if y.zero? && node.tag? && (!tagname || node.tagname! == tagname) &&
+           (!id || node.id! == id) && (cls - node.cls!).empty? &&
+           (!fun || fun.call(node))
+          # Guardamos porque pudiera ser que el parametro
+          # tagname fuera nil
+          close_tagname = node.tagname!
+          y += 1
+
+        elsif y && node.tag? && node.tagname! == close_tagname
+          y += 1
+
+        end
+
+        buff << node if y > 0
+
+        y -= 1 if y > 0 && node.closetag? && node.tagname! == close_tagname
+
+        next unless buff && y.zero?
+        yield Html.new(buff)
+        buff = []
+        close_tagname = nil
+      end
+    end
+
+    def search(**kws)
+      return Collection.new([self]).search(kws) if kws[:css]
+      list = []
+      isearch(**kws) { |val| list << val unless val.empty? }
+      Collection.new(list)
+    end
+
+    def css(query)
+      Collection.new([self]).css(query)
+    end
+
+    def find(**kws)
+      isearch(**kws) { |val| return val unless val.empty? }
+      nil
+    end
+
+    def rebuild
+      map(&:content).join
+    end
+
+    def texts
+      each_with_object([]) { |node, acc| acc << node.content if node.type == :notag }
+    end
+
+    def comments
+      each_with_object([]) { |node, acc| acc << node.content.sub(/^<!--/, "").sub(/-->$/, "") if node.type == :comment }
+    end
+
+    def joinedtexts
+      texts.join.gsub(/[\r\n\s]+/, " ").strip
+    end
+
+    def attr(name)
+      first.attr(name)
+    end
+
+    def id
+      first.id
+    end
+
+    def to_s
+      rebuild
+    end
+
+    %i(src href title).each do |m|
+      define_method(m) { self.attr(m) }
+    end
+  end
+end

data/lib/foxy/html_response.rb

@@ -0,0 +1,29 @@
+module Foxy
+  class HtmlResponse
+    attr_accessor :html, :params
+
+    def initialize(html, params)
+      @html = html
+      @params = params
+    end
+
+    def foxy
+      @foxy ||= Foxy::Html.new(@html)
+    end
+
+    def clean
+      @clean ||= foxy.clean(allow: %w(alt src href title class))
+    end
+
+    protected
+
+    def is_number(hash, key)
+      hash[key] = hash[key].try(:gsub, ",", "").try(:to_i) if hash[key]
+    end
+
+    def is_list(hash, key, sep = /\s*,\s*/)
+      return if hash[key].is_a? Array
+      hash[key] = hash[key].to_s.split(sep)
+    end
+  end
+end

data/lib/foxy/node.rb

@@ -0,0 +1,106 @@
+require "delegate"
+
+module Foxy
+  Node = Struct.new(:type, :content, :extra) do
+    include Monads
+
+    def attr(name)
+      value = attr_regex(name).match(content)
+      value && value[1].sub(/\A('|")?/, "").sub(/('|")?\Z/, "")
+    end
+
+    def tag?
+      [:tag, :singletag].include? type
+    end
+
+    def closetag?
+      [:closetag, :singletag].include? type
+    end
+
+    def tagname
+      (tag? || closetag?) && tagname!
+    end
+
+    def id
+      tag? && id!
+    end
+
+    def tagname!
+      extra[0]
+    end
+
+    def id!
+      extra[1]
+    end
+
+    def cls!
+      extra[2]
+    end
+
+    def clean(translate_table: {}, allow: ALLOW)
+      if [:tag, :singletag, :closetag].include? type
+        name = extra[0].downcase
+        slash1 = tag? ? "" : "/"
+        slash2 = (tag? && closetag?) ? "/" : ""
+        allow.each do |attr_name|
+          attr_value = attr(attr_name)
+          slash2 = " #{attr_name}=\"#{attr_value}\"#{slash2}" if attr_value
+        end
+        name = translate_table.fetch(name, name)
+        content = "<#{slash1}#{name}#{slash2}>"
+
+        id = allow.include?("id") ? extra[1] : nil
+        cls = allow.include?("class") ? extra[2] : []
+        return Node.new(type, content, [name, id, cls])
+      end
+      self
+    end
+
+    def attr_regex(name)
+      /#{name}=(("[^"]*")|('[^']*')|[^\s>]+)/mi
+    end
+
+    def self.build(closetag, singletag, tag, notag, comment, other)
+      if tag
+        tagname = RE_TAG.match(tag)[1]
+        id = RE_TAG_ID.match(tag)
+        id &&= id[1].gsub(/\A('|")*|('|")*\Z/, "")
+        cls = RE_TAG_CLS.match(tag)
+        cls = cls && cls[1].gsub(/\A('|")*|('|")*\Z/, "").split || []
+        if SINGLES.include? tagname
+          Node.new(:singletag, tag, [tagname, id, cls])
+        else
+          Node.new(:tag, tag, [tagname, id, cls])
+        end
+      elsif singletag
+        tagname = RE_TAG.match(singletag)[1]
+        id = RE_TAG_ID.match(singletag)
+        id &&= id[1].gsub(/\A('|")*|('|")*\Z/, "")
+        cls = RE_TAG_CLS.match(singletag)
+        cls = cls && cls[1].gsub(/\A('|")*|('|")*\Z/, "").split || []
+        Node.new(:singletag, singletag, [tagname, id, cls])
+      elsif closetag
+        closetagname = RE_CLOSETAG.match(closetag)[1]
+        Node.new(:closetag, closetag, [closetagname])
+      elsif notag
+        Node.new(:notag, notag, nil)
+      elsif comment
+        Node.new(:comment, comment, nil)
+      elsif other
+        Node.new(:notag, other, nil)
+      end
+    end
+
+    # def to_s
+    #   super.sub("#<struct ", "#<" )
+    # end
+
+    # def inspect
+    #   super.sub("#<struct ", "#<" )
+    # end
+
+    # def pretty_print(q)
+    #   q.text inspect
+    # end
+  end
+end

data/lib/foxy/rate_limit.rb

@@ -0,0 +1,19 @@
+module Foxy
+  module RateLimit
+    private
+
+    attr_reader :rate_limit
+
+    def interval
+      1.0 / rate_limit
+    end
+
+    def wait!
+      return unless rate_limit
+      @last ||= 0
+      delta = interval - (Time.now.to_f - @last.to_f)
+      sleep(delta) if delta > 0
+      @last = Time.now.to_f
+    end
+  end
+end

data/lib/foxy/repository.rb

@@ -0,0 +1,111 @@
+require 'yaml/store'
+
+require 'foxy/storages/yaml'
+
+module Foxy
+  class Repository
+    attr_reader :pk, :collection, :storage, :model, :class_key
+
+    def initialize(collection: nil, pk: :id, storage: Foxy::Storages::Yaml, model: true, class_key: :class)
+      @collection = collection || class_name.downcase
+      @pk = pk
+      @storage = storage
+      @model = model == true ? find_model : model
+      @class_key = class_key
+    end
+
+    def find_or_create(entity)
+      deserialize find_or_create! serialize entity
+    end
+
+    def find(id)
+      deserialize find! id
+    end
+
+    def all
+      deserialize_collection store.all
+    end
+
+    def where(query={})
+      deserialize_collection where!(query)
+    end
+
+    def create(entity)
+      deserialize create! serialize entity
+    end
+
+    def update(entity, attrs)
+      deserialize update! (serialize entity), attrs
+    end
+
+    def save(entity)
+      deserialize save! serialize entity
+    end
+
+    def destroy(entity)
+      destroy! serialize entity
+    end
+
+    def destroy_all
+      store.destroy_all
+    end
+
+    private
+
+    def store
+      @store ||= storage.new(collection)
+    end
+
+    def serialize entity
+      return entity.merge(class_key => model.name) if model && entity.is_a?(Hash)
+      raise "#{entity} is not a #{model.class}" if model && !entity.is_a?(model)
+      entity.serializable_hash.deep_symbolize_keys.merge(class_key => entity.class.name)
+    end
+
+    def deserialize hash
+      type = hash.delete(class_key)
+      (model || Object.const_get(type)).new(hash)
+    end
+
+    def deserialize_collection(collection)
+      collection.map{ |e| deserialize(e) }
+    end
+
+    def where!(query)
+      store.where(query)
+    end
+
+    def create!(attrs)
+      store.add attrs
+    end
+
+    def find!(id)
+      where!(pk => id).first
+    end
+
+    def find_or_create!(attrs)
+      find!(attrs[pk]) || create!(attrs)
+    end
+
+    def save!(attrs)
+      destroy! attrs
+      create! attrs
+    end
+
+    def update!(attrs, more)
+      store.update(attrs) { |item| item.merge!(more) }.first
+    end
+
+    def destroy!(attrs)
+      store.delete(pk => attrs[pk])
+    end
+
+    def find_model
+      Object.const_get(class_name)
+    end
+
+    def class_name
+      self.class.name.split('::').last
+    end
+  end
+end

data/lib/foxy/storages/yaml.rb

@@ -0,0 +1,77 @@
+require 'yaml/store'
+
+module Foxy
+  module Storages
+    class Yaml
+      attr_accessor :collection
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def where(attrs)
+        all.select(&query(attrs))
+      end
+
+      def add(attrs)
+        attrs.tap { store.transaction { all! << attrs } }
+      end
+
+      def all
+        store.transaction { all! }
+      end
+
+      def delete(attrs)
+        store.transaction {
+          before = all!.count
+          all!.delete_if(&query(attrs))
+          before - all!.count
+        }
+      end
+
+      def update(attrs, &block)
+        store.transaction { all!.select(&query(attrs)).each(&block) }
+      end
+
+      def delete_all
+        File.delete store.path if File.exist? store.path
+        @store = nil
+
+        true
+      end
+
+      private
+
+      def store_folder
+        "store"
+      end
+
+      def store
+        @store ||= store!
+      end
+
+      def query(attrs)
+        keys, values = attrs.keys, attrs.values
+
+        Proc.new { |item| item.values_at(*keys) == values }
+      end
+
+      def all!
+        store[:items] ||= []
+      end
+
+      def store!
+        FileUtils.makedir_p(store_folder.split("/"))
+        YAML::Store.new(path).tap { |s| s.transaction { s[:items] ||= [] } }
+      end
+
+      def path
+        "#{store_folder}/#{collection}#{env}.store.yaml"
+      end
+
+      def env
+        Foxy.env && "-#{Foxy.env}"
+      end
+    end
+  end
+end

data/lib/foxy/version.rb

@@ -0,0 +1,3 @@
+module Foxy
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: foxy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Manuel Albarrán
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A set of foxy tools for make easy retrieve information for another servers.
+email:
+- weap88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- foxy.gemspec
+- lib/foxy.rb
+- lib/foxy/adverb.rb
+- lib/foxy/client.rb
+- lib/foxy/collection.rb
+- lib/foxy/extensions.rb
+- lib/foxy/file_cache.rb
+- lib/foxy/html.rb
+- lib/foxy/html_response.rb
+- lib/foxy/node.rb
+- lib/foxy/rate_limit.rb
+- lib/foxy/repository.rb
+- lib/foxy/storages/yaml.rb
+- lib/foxy/version.rb
+homepage: https://github.com/weapp/foxyrb
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Foxy tools for foxy things.
+test_files: []
+has_rdoc: